diff --git a/src/class_linker.cc b/src/class_linker.cc
index 10e2e5e..7b8a02e 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -53,34 +53,32 @@
 
 namespace art {
 
-namespace {
-
-void ThrowNoClassDefFoundError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
-void ThrowNoClassDefFoundError(const char* fmt, ...) {
+static void ThrowNoClassDefFoundError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
+static void ThrowNoClassDefFoundError(const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
   Thread::Current()->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
   va_end(args);
 }
 
-void ThrowClassFormatError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
-void ThrowClassFormatError(const char* fmt, ...) {
+static void ThrowClassFormatError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
+static void ThrowClassFormatError(const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
   Thread::Current()->ThrowNewExceptionV("Ljava/lang/ClassFormatError;", fmt, args);
   va_end(args);
 }
 
-void ThrowLinkageError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
-void ThrowLinkageError(const char* fmt, ...) {
+static void ThrowLinkageError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
+static void ThrowLinkageError(const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
   Thread::Current()->ThrowNewExceptionV("Ljava/lang/LinkageError;", fmt, args);
   va_end(args);
 }
 
-void ThrowNoSuchMethodError(bool is_direct, Class* c, const StringPiece& name,
-                            const StringPiece& signature) {
+static void ThrowNoSuchMethodError(bool is_direct, Class* c, const StringPiece& name,
+                                   const StringPiece& signature) {
   ClassHelper kh(c);
   std::ostringstream msg;
   msg << "no " << (is_direct ? "direct" : "virtual") << " method " << name << signature
@@ -92,8 +90,8 @@
   Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
 }
 
-void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
-                           const StringPiece& name) {
+static void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
+                                  const StringPiece& name) {
   ClassHelper kh(c);
   std::ostringstream msg;
   msg << "no " << scope << "field " << name << " of type " << type
@@ -105,15 +103,15 @@
   Thread::Current()->ThrowNewException("Ljava/lang/NoSuchFieldError;", msg.str().c_str());
 }
 
-void ThrowNullPointerException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
-void ThrowNullPointerException(const char* fmt, ...) {
+static void ThrowNullPointerException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
+static void ThrowNullPointerException(const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
   Thread::Current()->ThrowNewExceptionV("Ljava/lang/NullPointerException;", fmt, args);
   va_end(args);
 }
 
-void ThrowEarlierClassFailure(Class* c) {
+static void ThrowEarlierClassFailure(Class* c) {
   /*
    * The class failed to initialize on a previous attempt, so we want to throw
    * a NoClassDefFoundError (v2 2.17.5).  The exception to this rule is if we
@@ -133,7 +131,7 @@
   }
 }
 
-void WrapExceptionInInitializer() {
+static void WrapExceptionInInitializer() {
   JNIEnv* env = Thread::Current()->GetJniEnv();
 
   ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
@@ -171,8 +169,6 @@
   return hash;
 }
 
-}  // namespace
-
 const char* ClassLinker::class_roots_descriptors_[] = {
   "Ljava/lang/Class;",
   "Ljava/lang/Object;",
diff --git a/src/dalvik_system_DexFile.cc b/src/dalvik_system_DexFile.cc
index c768776..2b86b76 100644
--- a/src/dalvik_system_DexFile.cc
+++ b/src/dalvik_system_DexFile.cc
@@ -31,8 +31,6 @@
 
 namespace art {
 
-namespace {
-
 // A smart pointer that provides read-only access to a Java string's UTF chars.
 // Unlike libcore's NullableScopedUtfChars, this will *not* throw NullPointerException if
 // passed a null jstring. The correct idiom is:
@@ -113,7 +111,7 @@
   return dex_file;
 }
 
-void DexFile_closeDexFile(JNIEnv* env, jclass, jint cookie) {
+static void DexFile_closeDexFile(JNIEnv* env, jclass, jint cookie) {
   const DexFile* dex_file = toDexFile(env, cookie);
   if (dex_file == NULL) {
     return;
@@ -124,8 +122,8 @@
   delete dex_file;
 }
 
-jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, jobject javaLoader,
-                                 jint cookie) {
+static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, jobject javaLoader,
+                                        jint cookie) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   const DexFile* dex_file = toDexFile(env, cookie);
   if (dex_file == NULL) {
@@ -149,7 +147,7 @@
   return AddLocalReference<jclass>(env, result);
 }
 
-jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jint cookie) {
+static jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jint cookie) {
   const DexFile* dex_file = toDexFile(env, cookie);
   if (dex_file == NULL) {
     return NULL;
@@ -164,7 +162,7 @@
   return toStringArray(env, class_names);
 }
 
-jboolean DexFile_isDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename) {
+static jboolean DexFile_isDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename) {
   bool debug_logging = false;
 
   ScopedUtfChars filename(env, javaFilename);
@@ -253,8 +251,6 @@
   NATIVE_METHOD(DexFile, openDexFile, "(Ljava/lang/String;Ljava/lang/String;I)I"),
 };
 
-}  // namespace
-
 void register_dalvik_system_DexFile(JNIEnv* env) {
   jniRegisterNativeMethods(env, "dalvik/system/DexFile", gMethods, NELEM(gMethods));
 }
diff --git a/src/dalvik_system_VMDebug.cc b/src/dalvik_system_VMDebug.cc
index 62a1f43..317cd3d 100644
--- a/src/dalvik_system_VMDebug.cc
+++ b/src/dalvik_system_VMDebug.cc
@@ -29,13 +29,11 @@
 
 namespace art {
 
-namespace {
-
 /*
  * Return a set of strings describing available VM features (this is chiefly
  * of interest to DDMS).
  */
-jobjectArray VMDebug_getVmFeatureList(JNIEnv* env, jclass) {
+static jobjectArray VMDebug_getVmFeatureList(JNIEnv* env, jclass) {
   std::vector<std::string> features;
   features.push_back("method-trace-profiling");
   features.push_back("method-trace-profiling-streaming");
@@ -44,27 +42,27 @@
   return toStringArray(env, features);
 }
 
-void VMDebug_startAllocCounting(JNIEnv*, jclass) {
+static void VMDebug_startAllocCounting(JNIEnv*, jclass) {
   Runtime::Current()->SetStatsEnabled(true);
 }
 
-void VMDebug_stopAllocCounting(JNIEnv*, jclass) {
+static void VMDebug_stopAllocCounting(JNIEnv*, jclass) {
   Runtime::Current()->SetStatsEnabled(false);
 }
 
-jint VMDebug_getAllocCount(JNIEnv* env, jclass, jint kind) {
+static jint VMDebug_getAllocCount(JNIEnv* env, jclass, jint kind) {
   return Runtime::Current()->GetStat(kind);
 }
 
-void VMDebug_resetAllocCount(JNIEnv*, jclass, jint kinds) {
+static void VMDebug_resetAllocCount(JNIEnv*, jclass, jint kinds) {
   Runtime::Current()->ResetStats(kinds);
 }
 
-void VMDebug_startMethodTracingDdmsImpl(JNIEnv* env, jclass, jint bufferSize, jint flags) {
+static void VMDebug_startMethodTracingDdmsImpl(JNIEnv* env, jclass, jint bufferSize, jint flags) {
   Trace::Start("[DDMS]", -1, bufferSize, flags, true);
 }
 
-void VMDebug_startMethodTracingFd(JNIEnv* env, jclass, jstring javaTraceFilename, jobject javaFd, jint bufferSize, jint flags) {
+static void VMDebug_startMethodTracingFd(JNIEnv* env, jclass, jstring javaTraceFilename, jobject javaFd, jint bufferSize, jint flags) {
   int originalFd = jniGetFDFromFileDescriptor(env, javaFd);
   if (originalFd < 0) {
     return;
@@ -83,7 +81,7 @@
   Trace::Start(traceFilename.c_str(), fd, bufferSize, flags, false);
 }
 
-void VMDebug_startMethodTracingFilename(JNIEnv* env, jclass, jstring javaTraceFilename, jint bufferSize, jint flags) {
+static void VMDebug_startMethodTracingFilename(JNIEnv* env, jclass, jstring javaTraceFilename, jint bufferSize, jint flags) {
   ScopedUtfChars traceFilename(env, javaTraceFilename);
   if (traceFilename.c_str() == NULL) {
     return;
@@ -91,57 +89,57 @@
   Trace::Start(traceFilename.c_str(), -1, bufferSize, flags, false);
 }
 
-jboolean VMDebug_isMethodTracingActive(JNIEnv*, jclass) {
+static jboolean VMDebug_isMethodTracingActive(JNIEnv*, jclass) {
   return Runtime::Current()->IsMethodTracingActive();
 }
 
-void VMDebug_stopMethodTracing(JNIEnv*, jclass) {
+static void VMDebug_stopMethodTracing(JNIEnv*, jclass) {
   Trace::Stop();
 }
 
-void VMDebug_startEmulatorTracing(JNIEnv*, jclass) {
+static void VMDebug_startEmulatorTracing(JNIEnv*, jclass) {
   UNIMPLEMENTED(WARNING);
   //dvmEmulatorTraceStart();
 }
 
-void VMDebug_stopEmulatorTracing(JNIEnv*, jclass) {
+static void VMDebug_stopEmulatorTracing(JNIEnv*, jclass) {
   UNIMPLEMENTED(WARNING);
   //dvmEmulatorTraceStop();
 }
 
-jboolean VMDebug_isDebuggerConnected(JNIEnv*, jclass) {
+static jboolean VMDebug_isDebuggerConnected(JNIEnv*, jclass) {
   return Dbg::IsDebuggerConnected();
 }
 
-jboolean VMDebug_isDebuggingEnabled(JNIEnv*, jclass) {
+static jboolean VMDebug_isDebuggingEnabled(JNIEnv*, jclass) {
   return Dbg::IsDebuggingEnabled();
 }
 
-jlong VMDebug_lastDebuggerActivity(JNIEnv*, jclass) {
+static jlong VMDebug_lastDebuggerActivity(JNIEnv*, jclass) {
   return Dbg::LastDebuggerActivity();
 }
 
-void VMDebug_startInstructionCounting(JNIEnv* env, jclass) {
+static void VMDebug_startInstructionCounting(JNIEnv* env, jclass) {
   jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
 }
 
-void VMDebug_stopInstructionCounting(JNIEnv* env, jclass) {
+static void VMDebug_stopInstructionCounting(JNIEnv* env, jclass) {
   jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
 }
 
-void VMDebug_getInstructionCount(JNIEnv* env, jclass, jintArray javaCounts) {
+static void VMDebug_getInstructionCount(JNIEnv* env, jclass, jintArray javaCounts) {
   jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
 }
 
-void VMDebug_resetInstructionCount(JNIEnv* env, jclass) {
+static void VMDebug_resetInstructionCount(JNIEnv* env, jclass) {
   jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
 }
 
-void VMDebug_printLoadedClasses(JNIEnv*, jclass, jint flags) {
+static void VMDebug_printLoadedClasses(JNIEnv*, jclass, jint flags) {
   return Runtime::Current()->GetClassLinker()->DumpAllClasses(flags);
 }
 
-jint VMDebug_getLoadedClassCount(JNIEnv*, jclass) {
+static jint VMDebug_getLoadedClassCount(JNIEnv*, jclass) {
   return Runtime::Current()->GetClassLinker()->NumLoadedClasses();
 }
 
@@ -149,14 +147,8 @@
  * Returns the thread-specific CPU-time clock value for the current thread,
  * or -1 if the feature isn't supported.
  */
-jlong VMDebug_threadCpuTimeNanos(JNIEnv*, jclass) {
-#ifdef HAVE_POSIX_CLOCKS
-  struct timespec now;
-  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &now);
-  return static_cast<jlong>(now.tv_sec*1000000000LL + now.tv_nsec);
-#else
-  return -1LL;
-#endif
+static jlong VMDebug_threadCpuTimeNanos(JNIEnv*, jclass) {
+  return ThreadCpuNanoTime();
 }
 
 /*
@@ -165,7 +157,7 @@
  * Cause "hprof" data to be dumped.  We can throw an IOException if an
  * error occurs during file handling.
  */
-void VMDebug_dumpHprofData(JNIEnv* env, jclass, jstring javaFilename, jobject javaFd) {
+static void VMDebug_dumpHprofData(JNIEnv* env, jclass, jstring javaFilename, jobject javaFd) {
   // Only one of these may be NULL.
   if (javaFilename == NULL && javaFd == NULL) {
     jniThrowNullPointerException(env, "fileName == null && fd == null");
@@ -200,7 +192,7 @@
   }
 }
 
-void VMDebug_dumpHprofDataDdms(JNIEnv* env, jclass) {
+static void VMDebug_dumpHprofDataDdms(JNIEnv* env, jclass) {
   int result = hprof::DumpHeap("[DDMS]", -1, true);
   if (result != 0) {
     // TODO: ideally we'd throw something more specific based on actual failure
@@ -209,7 +201,7 @@
   }
 }
 
-void VMDebug_dumpReferenceTables(JNIEnv* env, jclass) {
+static void VMDebug_dumpReferenceTables(JNIEnv* env, jclass) {
   LOG(INFO) << "--- reference table dump ---";
 
   JNIEnvExt* e = reinterpret_cast<JNIEnvExt*>(env);
@@ -223,7 +215,7 @@
  * Dump the current thread's interpreted stack and abort the VM.  Useful
  * for seeing both interpreted and native stack traces.
  */
-void VMDebug_crash(JNIEnv*, jclass) {
+static void VMDebug_crash(JNIEnv*, jclass) {
   LOG(FATAL) << "Crashing VM on request";
 }
 
@@ -231,11 +223,11 @@
  * Provide a hook for gdb to hang to so that the VM can be stopped when
  * user-tagged source locations are being executed.
  */
-void VMDebug_infopoint(JNIEnv*, jclass, jint id) {
+static void VMDebug_infopoint(JNIEnv*, jclass, jint id) {
   LOG(INFO) << "VMDebug infopoint " << id << " hit";
 }
 
-jlong VMDebug_countInstancesOfClass(JNIEnv* env, jclass, jclass javaClass, jboolean countAssignable) {
+static jlong VMDebug_countInstancesOfClass(JNIEnv* env, jclass, jclass javaClass, jboolean countAssignable) {
   Class* c = Decode<Class*>(env, javaClass);
   if (c == NULL) {
     return 0;
@@ -243,7 +235,7 @@
   return Runtime::Current()->GetHeap()->CountInstances(c, countAssignable);
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(VMDebug, countInstancesOfClass, "(Ljava/lang/Class;Z)J"),
   NATIVE_METHOD(VMDebug, crash, "()V"),
   NATIVE_METHOD(VMDebug, dumpHprofData, "(Ljava/lang/String;Ljava/io/FileDescriptor;)V"),
@@ -274,8 +266,6 @@
   NATIVE_METHOD(VMDebug, threadCpuTimeNanos, "()J"),
 };
 
-}  // namespace
-
 void register_dalvik_system_VMDebug(JNIEnv* env) {
   jniRegisterNativeMethods(env, "dalvik/system/VMDebug", gMethods, NELEM(gMethods));
 }
diff --git a/src/dalvik_system_VMRuntime.cc b/src/dalvik_system_VMRuntime.cc
index 33e6619..3799bcf 100644
--- a/src/dalvik_system_VMRuntime.cc
+++ b/src/dalvik_system_VMRuntime.cc
@@ -32,23 +32,21 @@
 
 namespace art {
 
-namespace {
-
-jfloat VMRuntime_getTargetHeapUtilization(JNIEnv*, jobject) {
+static jfloat VMRuntime_getTargetHeapUtilization(JNIEnv*, jobject) {
   return Runtime::Current()->GetHeap()->GetTargetHeapUtilization();
 }
 
-void VMRuntime_nativeSetTargetHeapUtilization(JNIEnv*, jobject, jfloat target) {
+static void VMRuntime_nativeSetTargetHeapUtilization(JNIEnv*, jobject, jfloat target) {
   Runtime::Current()->GetHeap()->SetTargetHeapUtilization(target);
 }
 
-void VMRuntime_startJitCompilation(JNIEnv*, jobject) {
+static void VMRuntime_startJitCompilation(JNIEnv*, jobject) {
 }
 
-void VMRuntime_disableJitCompilation(JNIEnv*, jobject) {
+static void VMRuntime_disableJitCompilation(JNIEnv*, jobject) {
 }
 
-jobject VMRuntime_newNonMovableArray(JNIEnv* env, jobject, jclass javaElementClass, jint length) {
+static jobject VMRuntime_newNonMovableArray(JNIEnv* env, jobject, jclass javaElementClass, jint length) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
 #ifdef MOVING_GARBAGE_COLLECTOR
   // TODO: right now, we don't have a copying collector, so there's no need
@@ -79,7 +77,7 @@
   return AddLocalReference<jobject>(env, result);
 }
 
-jlong VMRuntime_addressOf(JNIEnv* env, jobject, jobject javaArray) {
+static jlong VMRuntime_addressOf(JNIEnv* env, jobject, jobject javaArray) {
   if (javaArray == NULL) {  // Most likely allocation failed
     return 0;
   }
@@ -93,15 +91,15 @@
   return reinterpret_cast<uintptr_t>(array->GetRawData(array->GetClass()->GetComponentSize()));
 }
 
-void VMRuntime_clearGrowthLimit(JNIEnv*, jobject) {
+static void VMRuntime_clearGrowthLimit(JNIEnv*, jobject) {
   Runtime::Current()->GetHeap()->ClearGrowthLimit();
 }
 
-jboolean VMRuntime_isDebuggerActive(JNIEnv*, jobject) {
+static jboolean VMRuntime_isDebuggerActive(JNIEnv*, jobject) {
   return Dbg::IsDebuggerConnected();
 }
 
-jobjectArray VMRuntime_properties(JNIEnv* env, jobject) {
+static jobjectArray VMRuntime_properties(JNIEnv* env, jobject) {
   return toStringArray(env, Runtime::Current()->GetProperties());
 }
 
@@ -110,19 +108,19 @@
 // specified. Unfortunately, some tests were using java.class.path to
 // lookup relative file locations, so they are counting on this to be
 // ".", presumably some applications or libraries could have as well.
-const char* DefaultToDot(const std::string& class_path) {
+static const char* DefaultToDot(const std::string& class_path) {
   return class_path.empty() ? "." : class_path.c_str();
 }
 
-jstring VMRuntime_bootClassPath(JNIEnv* env, jobject) {
+static jstring VMRuntime_bootClassPath(JNIEnv* env, jobject) {
   return env->NewStringUTF(DefaultToDot(Runtime::Current()->GetBootClassPathString()));
 }
 
-jstring VMRuntime_classPath(JNIEnv* env, jobject) {
+static jstring VMRuntime_classPath(JNIEnv* env, jobject) {
   return env->NewStringUTF(DefaultToDot(Runtime::Current()->GetClassPathString()));
 }
 
-jstring VMRuntime_vmVersion(JNIEnv* env, jobject) {
+static jstring VMRuntime_vmVersion(JNIEnv* env, jobject) {
   return env->NewStringUTF(Runtime::Current()->GetVersion());
 }
 
@@ -131,7 +129,7 @@
   t->GetJniEnv()->SetCheckJniEnabled(false);
 }
 
-void VMRuntime_setTargetSdkVersion(JNIEnv* env, jobject, jint targetSdkVersion) {
+static void VMRuntime_setTargetSdkVersion(JNIEnv* env, jobject, jint targetSdkVersion) {
   // This is the target SDK version of the app we're about to run.
   // Note that targetSdkVersion may be CUR_DEVELOPMENT (10000).
   // Note that targetSdkVersion may be 0, meaning "current".
@@ -152,7 +150,7 @@
   }
 }
 
-void VMRuntime_trimHeap(JNIEnv* env, jobject) {
+static void VMRuntime_trimHeap(JNIEnv* env, jobject) {
   ScopedHeapLock heap_lock;
   Heap* heap = Runtime::Current()->GetHeap();
   size_t alloc_space_size = heap->GetAllocSpace()->Size();
@@ -164,7 +162,7 @@
             << " heap with " << static_cast<int>(100 * utilization) << "% utilization";
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(VMRuntime, addressOf, "(Ljava/lang/Object;)J"),
   NATIVE_METHOD(VMRuntime, bootClassPath, "()Ljava/lang/String;"),
   NATIVE_METHOD(VMRuntime, classPath, "()Ljava/lang/String;"),
@@ -181,8 +179,6 @@
   NATIVE_METHOD(VMRuntime, vmVersion, "()Ljava/lang/String;"),
 };
 
-}  // namespace
-
 void register_dalvik_system_VMRuntime(JNIEnv* env) {
   jniRegisterNativeMethods(env, "dalvik/system/VMRuntime", gMethods, NELEM(gMethods));
 }
diff --git a/src/dalvik_system_VMStack.cc b/src/dalvik_system_VMStack.cc
index 8560c22..7ba4d14 100644
--- a/src/dalvik_system_VMStack.cc
+++ b/src/dalvik_system_VMStack.cc
@@ -25,8 +25,6 @@
 
 namespace art {
 
-namespace {
-
 static jobject GetThreadStack(JNIEnv* env, jobject javaThread) {
   ScopedHeapLock heap_lock;
   ScopedThreadListLock thread_list_lock;
@@ -34,7 +32,7 @@
   return (thread != NULL) ? GetThreadStack(env, thread) : NULL;
 }
 
-jint VMStack_fillStackTraceElements(JNIEnv* env, jclass, jobject javaThread, jobjectArray javaSteArray) {
+static jint VMStack_fillStackTraceElements(JNIEnv* env, jclass, jobject javaThread, jobjectArray javaSteArray) {
   jobject trace = GetThreadStack(env, javaThread);
   if (trace == NULL) {
     return 0;
@@ -44,7 +42,7 @@
   return depth;
 }
 
-jobject VMStack_getCallingClassLoader(JNIEnv* env, jclass) {
+static jobject VMStack_getCallingClassLoader(JNIEnv* env, jclass) {
   // Returns the defining class loader of the caller's caller.
   // TODO: need SmartFrame (Thread::WalkStack-like iterator).
   Frame frame = Thread::Current()->GetTopOfStack();
@@ -56,7 +54,7 @@
   return AddLocalReference<jobject>(env, cl);
 }
 
-jobject VMStack_getClosestUserClassLoader(JNIEnv* env, jclass, jobject javaBootstrap, jobject javaSystem) {
+static jobject VMStack_getClosestUserClassLoader(JNIEnv* env, jclass, jobject javaBootstrap, jobject javaSystem) {
   struct ClosestUserClassLoaderVisitor : public Thread::StackVisitor {
     ClosestUserClassLoaderVisitor(Object* bootstrap, Object* system)
       : bootstrap(bootstrap), system(system), class_loader(NULL) {}
@@ -81,7 +79,7 @@
   return AddLocalReference<jobject>(env, visitor.class_loader);
 }
 
-jclass VMStack_getStackClass2(JNIEnv* env, jclass) {
+static jclass VMStack_getStackClass2(JNIEnv* env, jclass) {
   // Returns the class of the caller's caller's caller.
   // TODO: need SmartFrame (Thread::WalkStack-like iterator).
   Frame frame = Thread::Current()->GetTopOfStack();
@@ -94,7 +92,7 @@
   return AddLocalReference<jclass>(env, c);
 }
 
-jobjectArray VMStack_getThreadStackTrace(JNIEnv* env, jclass, jobject javaThread) {
+static jobjectArray VMStack_getThreadStackTrace(JNIEnv* env, jclass, jobject javaThread) {
   jobject trace = GetThreadStack(env, javaThread);
   if (trace == NULL) {
     return NULL;
@@ -110,8 +108,6 @@
   NATIVE_METHOD(VMStack, getThreadStackTrace, "(Ljava/lang/Thread;)[Ljava/lang/StackTraceElement;"),
 };
 
-}  // namespace
-
 void register_dalvik_system_VMStack(JNIEnv* env) {
   jniRegisterNativeMethods(env, "dalvik/system/VMStack", gMethods, NELEM(gMethods));
 }
diff --git a/src/dalvik_system_Zygote.cc b/src/dalvik_system_Zygote.cc
index 3f57bfcd..3ba5552 100644
--- a/src/dalvik_system_Zygote.cc
+++ b/src/dalvik_system_Zygote.cc
@@ -37,11 +37,9 @@
 
 namespace art {
 
-namespace {
-
 static pid_t gSystemServerPid = 0;
 
-void Zygote_nativeExecShell(JNIEnv* env, jclass, jstring javaCommand) {
+static void Zygote_nativeExecShell(JNIEnv* env, jclass, jstring javaCommand) {
   ScopedUtfChars command(env, javaCommand);
   if (command.c_str() == NULL) {
     return;
@@ -53,9 +51,8 @@
   exit(127);
 }
 
-
 // This signal handler is for zygote mode, since the zygote must reap its children
-void SigChldHandler(int s) {
+static void SigChldHandler(int s) {
   pid_t pid;
   int status;
 
@@ -100,14 +97,14 @@
   }
 }
 
-// configure sigchld handler for the zygote process This is configured
+// Configures the SIGCHLD handler for the zygote process. This is configured
 // very late, because earlier in the runtime we may fork() and exec()
 // other processes, and we want to waitpid() for those rather than
 // have them be harvested immediately.
 //
 // This ends up being called repeatedly before each fork(), but there's
 // no real harm in that.
-void SetSigChldHandler() {
+static void SetSigChldHandler() {
   struct sigaction sa;
   memset(&sa, 0, sizeof(sa));
   sa.sa_handler = SigChldHandler;
@@ -118,8 +115,8 @@
   }
 }
 
-// Set the SIGCHLD handler back to default behavior in zygote children
-void UnsetSigChldHandler() {
+// Sets the SIGCHLD handler back to default behavior in zygote children.
+static void UnsetSigChldHandler() {
   struct sigaction sa;
   memset(&sa, 0, sizeof(sa));
   sa.sa_handler = SIG_DFL;
@@ -132,7 +129,7 @@
 
 // Calls POSIX setgroups() using the int[] object as an argument.
 // A NULL argument is tolerated.
-int SetGids(JNIEnv* env, jintArray javaGids) {
+static int SetGids(JNIEnv* env, jintArray javaGids) {
   if (javaGids == NULL) {
     return 0;
   }
@@ -151,7 +148,7 @@
 // treated as an empty array.
 //
 // -1 is returned on error.
-int SetRLimits(JNIEnv* env, jobjectArray javaRlimits) {
+static int SetRLimits(JNIEnv* env, jobjectArray javaRlimits) {
   if (javaRlimits == NULL) {
     return 0;
   }
@@ -178,7 +175,7 @@
   return 0;
 }
 
-void SetCapabilities(int64_t permitted, int64_t effective) {
+static void SetCapabilities(int64_t permitted, int64_t effective) {
 #ifdef HAVE_ANDROID_OS
   struct __user_cap_header_struct capheader;
   struct __user_cap_data_struct capdata;
@@ -198,7 +195,7 @@
 #endif /*HAVE_ANDROID_OS*/
 }
 
-void EnableDebugFeatures(uint32_t debug_flags) {
+static void EnableDebugFeatures(uint32_t debug_flags) {
   // Must match values in dalvik.system.Zygote.
   enum {
     DEBUG_ENABLE_DEBUGGER           = 1,
@@ -264,9 +261,9 @@
 #endif
 
 // Utility routine to fork zygote and specialize the child process.
-pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids,
-                              jint debug_flags, jobjectArray javaRlimits,
-                              jlong permittedCapabilities, jlong effectiveCapabilities) {
+static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids,
+                                     jint debug_flags, jobjectArray javaRlimits,
+                                     jlong permittedCapabilities, jlong effectiveCapabilities) {
   Runtime* runtime = Runtime::Current();
   CHECK(runtime->IsZygote()) << "runtime instance not started with -Xzygote";
   if (false) { // TODO: do we need do anything special like !dvmGcPreZygoteFork()?
@@ -331,14 +328,14 @@
   return pid;
 }
 
-jint Zygote_nativeForkAndSpecialize(JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
-                                    jint debug_flags, jobjectArray rlimits) {
+static jint Zygote_nativeForkAndSpecialize(JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
+                                           jint debug_flags, jobjectArray rlimits) {
   return ForkAndSpecializeCommon(env, uid, gid, gids, debug_flags, rlimits, 0, 0);
 }
 
-jint Zygote_nativeForkSystemServer(JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
-                                   jint debug_flags, jobjectArray rlimits,
-                                   jlong permittedCapabilities, jlong effectiveCapabilities) {
+static jint Zygote_nativeForkSystemServer(JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
+                                          jint debug_flags, jobjectArray rlimits,
+                                          jlong permittedCapabilities, jlong effectiveCapabilities) {
   pid_t pid = ForkAndSpecializeCommon(env, uid, gid, gids,
                                       debug_flags, rlimits,
                                       permittedCapabilities, effectiveCapabilities);
@@ -364,8 +361,6 @@
   NATIVE_METHOD(Zygote, nativeForkSystemServer, "(II[II[[IJJ)I"),
 };
 
-}  // namespace
-
 void register_dalvik_system_Zygote(JNIEnv* env) {
   jniRegisterNativeMethods(env, "dalvik/system/Zygote", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_Class.cc b/src/java_lang_Class.cc
index c2cca5b..3dce559 100644
--- a/src/java_lang_Class.cc
+++ b/src/java_lang_Class.cc
@@ -26,10 +26,8 @@
 
 namespace art {
 
-namespace {
-
 // "name" is in "binary name" format, e.g. "dalvik.system.Debug$1".
-jclass Class_classForName(JNIEnv* env, jclass, jstring javaName, jboolean initialize, jobject javaLoader) {
+static jclass Class_classForName(JNIEnv* env, jclass, jstring javaName, jboolean initialize, jobject javaLoader) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   ScopedUtfChars name(env, javaName);
   if (name.c_str() == NULL) {
@@ -65,7 +63,7 @@
   return AddLocalReference<jclass>(env, c);
 }
 
-jint Class_getAnnotationDirectoryOffset(JNIEnv* env, jclass javaClass) {
+static jint Class_getAnnotationDirectoryOffset(JNIEnv* env, jclass javaClass) {
   Class* c = Decode<Class*>(env, javaClass);
   if (c->IsPrimitive() || c->IsArrayClass() || c->IsProxyClass()) {
     return 0;  // primitive, array and proxy classes don't have class definitions
@@ -79,7 +77,7 @@
 }
 
 template<typename T>
-jobjectArray ToArray(JNIEnv* env, const char* array_class_name, const std::vector<T*>& objects) {
+static jobjectArray ToArray(JNIEnv* env, const char* array_class_name, const std::vector<T*>& objects) {
   jclass array_class = env->FindClass(array_class_name);
   jobjectArray result = env->NewObjectArray(objects.size(), array_class, NULL);
   for (size_t i = 0; i < objects.size(); ++i) {
@@ -99,7 +97,7 @@
   return m->IsConstructor();
 }
 
-jobjectArray Class_getDeclaredConstructors(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
+static jobjectArray Class_getDeclaredConstructors(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
   Class* c = Decode<Class*>(env, javaClass);
 
   std::vector<Method*> constructors;
@@ -120,7 +118,7 @@
   return true;
 }
 
-jobjectArray Class_getDeclaredFields(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
+static jobjectArray Class_getDeclaredFields(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
   Class* c = Decode<Class*>(env, javaClass);
 
   std::vector<Field*> fields;
@@ -159,7 +157,7 @@
   return true;
 }
 
-jobjectArray Class_getDeclaredMethods(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
+static jobjectArray Class_getDeclaredMethods(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
   Class* c = Decode<Class*>(env, javaClass);
   std::vector<Method*> methods;
   for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
@@ -184,7 +182,7 @@
   return ToArray(env, "java/lang/reflect/Method", methods);
 }
 
-jobject Class_getDex(JNIEnv* env, jobject javaClass) {
+static jobject Class_getDex(JNIEnv* env, jobject javaClass) {
   Class* c = Decode<Class*>(env, javaClass);
 
   DexCache* dex_cache = c->GetDexCache();
@@ -242,8 +240,8 @@
   return result;
 }
 
-jobject Class_getDeclaredConstructorOrMethod(JNIEnv* env, jclass javaClass, jstring javaName,
-                                             jobjectArray javaArgs) {
+static jobject Class_getDeclaredConstructorOrMethod(JNIEnv* env, jclass javaClass, jstring javaName,
+                                                    jobjectArray javaArgs) {
   Class* c = Decode<Class*>(env, javaClass);
   std::string name(Decode<String*>(env, javaName)->ToModifiedUtf8());
   ObjectArray<Class>* arg_array = Decode<ObjectArray<Class>*>(env, javaArgs);
@@ -260,7 +258,7 @@
   }
 }
 
-jobject Class_getDeclaredFieldNative(JNIEnv* env, jclass jklass, jobject jname) {
+static jobject Class_getDeclaredFieldNative(JNIEnv* env, jclass jklass, jobject jname) {
   Class* klass = Decode<Class*>(env, jklass);
   DCHECK(klass->IsClass());
   String* name = Decode<String*>(env, jname);
@@ -284,13 +282,13 @@
   return NULL;
 }
 
-jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
+static jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Class* c = Decode<Class*>(env, javaThis);
   return AddLocalReference<jstring>(env, c->ComputeName());
 }
 
-jboolean Class_isAssignableFrom(JNIEnv* env, jobject javaLhs, jclass javaRhs) {
+static jboolean Class_isAssignableFrom(JNIEnv* env, jobject javaLhs, jclass javaRhs) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Class* lhs = Decode<Class*>(env, javaLhs);
   Class* rhs = Decode<Class*>(env, javaRhs);
@@ -301,7 +299,7 @@
   return lhs->IsAssignableFrom(rhs) ? JNI_TRUE : JNI_FALSE;
 }
 
-jboolean Class_isInstance(JNIEnv* env, jobject javaClass, jobject javaObject) {
+static jboolean Class_isInstance(JNIEnv* env, jobject javaClass, jobject javaObject) {
   Class* c = Decode<Class*>(env, javaClass);
   Object* o = Decode<Object*>(env, javaObject);
   if (o == NULL) {
@@ -339,7 +337,7 @@
   return access_from->IsInSamePackage(access_to);
 }
 
-jobject Class_newInstanceImpl(JNIEnv* env, jobject javaThis) {
+static jobject Class_newInstanceImpl(JNIEnv* env, jobject javaThis) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Class* c = Decode<Class*>(env, javaThis);
   if (c->IsPrimitive() || c->IsInterface() || c->IsArrayClass() || c->IsAbstract()) {
@@ -417,8 +415,6 @@
   NATIVE_METHOD(Class, newInstanceImpl, "()Ljava/lang/Object;"),
 };
 
-}  // namespace
-
 void register_java_lang_Class(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/Class", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_Object.cc b/src/java_lang_Object.cc
index 7c72604..f95d1a1 100644
--- a/src/java_lang_Object.cc
+++ b/src/java_lang_Object.cc
@@ -21,38 +21,34 @@
 
 namespace art {
 
-namespace {
-
-jobject Object_internalClone(JNIEnv* env, jobject javaThis) {
+static jobject Object_internalClone(JNIEnv* env, jobject javaThis) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Object* o = Decode<Object*>(env, javaThis);
   return AddLocalReference<jobject>(env, o->Clone());
 }
 
-void Object_notify(JNIEnv* env, jobject javaThis) {
+static void Object_notify(JNIEnv* env, jobject javaThis) {
   Object* o = Decode<Object*>(env, javaThis);
   o->Notify();
 }
 
-void Object_notifyAll(JNIEnv* env, jobject javaThis) {
+static void Object_notifyAll(JNIEnv* env, jobject javaThis) {
   Object* o = Decode<Object*>(env, javaThis);
   o->NotifyAll();
 }
 
-void Object_wait(JNIEnv* env, jobject javaThis, jlong ms, jint ns) {
+static void Object_wait(JNIEnv* env, jobject javaThis, jlong ms, jint ns) {
   Object* o = Decode<Object*>(env, javaThis);
   o->Wait(ms, ns);
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(Object, internalClone, "(Ljava/lang/Cloneable;)Ljava/lang/Object;"),
   NATIVE_METHOD(Object, notify, "()V"),
   NATIVE_METHOD(Object, notifyAll, "()V"),
   NATIVE_METHOD(Object, wait, "(JI)V"),
 };
 
-}  // namespace
-
 void register_java_lang_Object(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/Object", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_Runtime.cc b/src/java_lang_Runtime.cc
index 07af162..a057d36 100644
--- a/src/java_lang_Runtime.cc
+++ b/src/java_lang_Runtime.cc
@@ -27,14 +27,12 @@
 
 namespace art {
 
-namespace {
-
-void Runtime_gc(JNIEnv*, jclass) {
+static void Runtime_gc(JNIEnv*, jclass) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Runtime::Current()->GetHeap()->CollectGarbage(false);
 }
 
-void Runtime_nativeExit(JNIEnv* env, jclass, jint status, jboolean isExit) {
+static void Runtime_nativeExit(JNIEnv* env, jclass, jint status, jboolean isExit) {
   // isExit is true for System.exit and false for System.halt.
   if (isExit) {
     Runtime::Current()->CallExitHook(status);
@@ -49,7 +47,7 @@
  * JNI-compatible methods. Returns null on success, or a failure
  * message on failure.
  */
-jstring Runtime_nativeLoad(JNIEnv* env, jclass, jstring javaFilename, jobject javaLoader) {
+static jstring Runtime_nativeLoad(JNIEnv* env, jclass, jstring javaFilename, jobject javaLoader) {
   ScopedUtfChars filename(env, javaFilename);
   if (filename.c_str() == NULL) {
     return NULL;
@@ -66,15 +64,15 @@
   return env->NewStringUTF(detail.c_str());
 }
 
-jlong Runtime_maxMemory(JNIEnv* env, jclass) {
+static jlong Runtime_maxMemory(JNIEnv* env, jclass) {
   return Runtime::Current()->GetHeap()->GetMaxMemory();
 }
 
-jlong Runtime_totalMemory(JNIEnv* env, jclass) {
+static jlong Runtime_totalMemory(JNIEnv* env, jclass) {
   return Runtime::Current()->GetHeap()->GetTotalMemory();
 }
 
-jlong Runtime_freeMemory(JNIEnv* env, jclass) {
+static jlong Runtime_freeMemory(JNIEnv* env, jclass) {
   return Runtime::Current()->GetHeap()->GetFreeMemory();
 }
 
@@ -87,8 +85,6 @@
     NATIVE_METHOD(Runtime, totalMemory, "()J"),
 };
 
-}  // namespace
-
 void register_java_lang_Runtime(JNIEnv* env) {
     jniRegisterNativeMethods(env, "java/lang/Runtime", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_String.cc b/src/java_lang_String.cc
index ff182e1..c549c08 100644
--- a/src/java_lang_String.cc
+++ b/src/java_lang_String.cc
@@ -36,9 +36,7 @@
 
 namespace art {
 
-namespace {
-
-jint String_compareTo(JNIEnv* env, jobject javaThis, jobject javaRhs) {
+static jint String_compareTo(JNIEnv* env, jobject javaThis, jobject javaRhs) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   String* lhs = Decode<String*>(env, javaThis);
   String* rhs = Decode<String*>(env, javaRhs);
@@ -72,7 +70,7 @@
   return countDiff;
 }
 
-jboolean String_equals(JNIEnv* env, jobject javaThis, jobject javaRhs) {
+static jboolean String_equals(JNIEnv* env, jobject javaThis, jobject javaRhs) {
   String* lhs = Decode<String*>(env, javaThis);
   String* rhs = Decode<String*>(env, javaRhs);
 
@@ -128,7 +126,7 @@
  *
  * Returns -1 if no match is found.
  */
-jint String_fastIndexOf(JNIEnv* env, jobject javaThis, jint ch, jint start) {
+static jint String_fastIndexOf(JNIEnv* env, jobject javaThis, jint ch, jint start) {
   String* s = Decode<String*>(env, javaThis);
   const uint16_t* chars = s->GetCharArray()->GetData() + s->GetOffset();
 
@@ -148,21 +146,19 @@
   return -1;
 }
 
-jstring String_intern(JNIEnv* env, jobject javaThis) {
+static jstring String_intern(JNIEnv* env, jobject javaThis) {
   String* s = Decode<String*>(env, javaThis);
   String* result = s->Intern();
   return AddLocalReference<jstring>(env, result);
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(String, compareTo, "(Ljava/lang/String;)I"),
   NATIVE_METHOD(String, equals, "(Ljava/lang/Object;)Z"),
   NATIVE_METHOD(String, fastIndexOf, "(II)I"),
   NATIVE_METHOD(String, intern, "()Ljava/lang/String;"),
 };
 
-}  // namespace
-
 void register_java_lang_String(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/String", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_System.cc b/src/java_lang_System.cc
index 22a9cc6..fa8257b 100644
--- a/src/java_lang_System.cc
+++ b/src/java_lang_System.cc
@@ -102,15 +102,13 @@
 
 namespace art {
 
-namespace {
-
-void ThrowArrayStoreException_NotAnArray(const char* identifier, Object* array) {
+static void ThrowArrayStoreException_NotAnArray(const char* identifier, Object* array) {
   std::string actualType(PrettyTypeOf(array));
   Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
       "%s of type %s is not an array", identifier, actualType.c_str());
 }
 
-void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, jobject javaDst, jint dstPos, jint length) {
+static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, jobject javaDst, jint dstPos, jint length) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Thread* self = Thread::Current();
 
@@ -244,18 +242,16 @@
   }
 }
 
-jint System_identityHashCode(JNIEnv* env, jclass, jobject javaObject) {
+static jint System_identityHashCode(JNIEnv* env, jclass, jobject javaObject) {
   Object* o = Decode<Object*>(env, javaObject);
   return static_cast<jint>(reinterpret_cast<uintptr_t>(o));
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(System, arraycopy, "(Ljava/lang/Object;ILjava/lang/Object;II)V"),
   NATIVE_METHOD(System, identityHashCode, "(Ljava/lang/Object;)I"),
 };
 
-}  // namespace
-
 void register_java_lang_System(JNIEnv* env) {
     jniRegisterNativeMethods(env, "java/lang/System", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_Thread.cc b/src/java_lang_Thread.cc
index f351f20..0871bdd 100644
--- a/src/java_lang_Thread.cc
+++ b/src/java_lang_Thread.cc
@@ -26,28 +26,26 @@
 
 namespace art {
 
-namespace {
-
-jobject Thread_currentThread(JNIEnv* env, jclass) {
+static jobject Thread_currentThread(JNIEnv* env, jclass) {
   return AddLocalReference<jobject>(env, Thread::Current()->GetPeer());
 }
 
-jboolean Thread_interrupted(JNIEnv* env, jclass) {
+static jboolean Thread_interrupted(JNIEnv* env, jclass) {
   return Thread::Current()->Interrupted();
 }
 
-jboolean Thread_isInterrupted(JNIEnv* env, jobject javaThread) {
+static jboolean Thread_isInterrupted(JNIEnv* env, jobject javaThread) {
   ScopedThreadListLock thread_list_lock;
   Thread* thread = Thread::FromManagedThread(env, javaThread);
   return (thread != NULL) ? thread->IsInterrupted() : JNI_FALSE;
 }
 
-void Thread_nativeCreate(JNIEnv* env, jclass, jobject javaThread, jlong stackSize) {
+static void Thread_nativeCreate(JNIEnv* env, jclass, jobject javaThread, jlong stackSize) {
   Object* managedThread = Decode<Object*>(env, javaThread);
   Thread::Create(managedThread, stackSize);
 }
 
-jint Thread_nativeGetStatus(JNIEnv* env, jobject javaThread) {
+static jint Thread_nativeGetStatus(JNIEnv* env, jobject javaThread) {
   ScopedThreadListLock thread_list_lock;
   Thread* thread = Thread::FromManagedThread(env, javaThread);
   if (thread == NULL) {
@@ -56,7 +54,7 @@
   return static_cast<jint>(thread->GetState());
 }
 
-jboolean Thread_nativeHoldsLock(JNIEnv* env, jobject javaThread, jobject javaObject) {
+static jboolean Thread_nativeHoldsLock(JNIEnv* env, jobject javaThread, jobject javaObject) {
   Object* object = Decode<Object*>(env, javaObject);
   if (object == NULL) {
     ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
@@ -68,7 +66,7 @@
   return thread->HoldsLock(object);
 }
 
-void Thread_nativeInterrupt(JNIEnv* env, jobject javaThread) {
+static void Thread_nativeInterrupt(JNIEnv* env, jobject javaThread) {
   ScopedThreadListLock thread_list_lock;
   Thread* thread = Thread::FromManagedThread(env, javaThread);
   if (thread != NULL) {
@@ -76,7 +74,7 @@
   }
 }
 
-void Thread_nativeSetName(JNIEnv* env, jobject javaThread, jstring javaName) {
+static void Thread_nativeSetName(JNIEnv* env, jobject javaThread, jstring javaName) {
   ScopedThreadListLock thread_list_lock;
   Thread* thread = Thread::FromManagedThread(env, javaThread);
   if (thread == NULL) {
@@ -94,7 +92,7 @@
  * from Thread.MIN_PRIORITY to Thread.MAX_PRIORITY (1-10), with "normal"
  * threads at Thread.NORM_PRIORITY (5).
  */
-void Thread_nativeSetPriority(JNIEnv* env, jobject javaThread, jint newPriority) {
+static void Thread_nativeSetPriority(JNIEnv* env, jobject javaThread, jint newPriority) {
   ScopedThreadListLock thread_list_lock;
   Thread* thread = Thread::FromManagedThread(env, javaThread);
   if (thread != NULL) {
@@ -108,7 +106,7 @@
  * The exact behavior is poorly defined.  Some discussion here:
  *   http://www.cs.umd.edu/~pugh/java/memoryModel/archive/0944.html
  */
-void Thread_yield(JNIEnv*, jobject) {
+static void Thread_yield(JNIEnv*, jobject) {
   sched_yield();
 }
 
@@ -125,8 +123,6 @@
   NATIVE_METHOD(Thread, yield, "()V"),
 };
 
-}  // namespace
-
 void register_java_lang_Thread(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/Thread", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_Throwable.cc b/src/java_lang_Throwable.cc
index 2ab4ed6..1d73027 100644
--- a/src/java_lang_Throwable.cc
+++ b/src/java_lang_Throwable.cc
@@ -21,27 +21,23 @@
 
 namespace art {
 
-namespace {
-
-jobject Throwable_nativeFillInStackTrace(JNIEnv* env, jclass) {
+static jobject Throwable_nativeFillInStackTrace(JNIEnv* env, jclass) {
   JNIEnvExt* env_ext = reinterpret_cast<JNIEnvExt*>(env);
   return env_ext->self->CreateInternalStackTrace(env);
 }
 
-jobjectArray Throwable_nativeGetStackTrace(JNIEnv* env, jclass, jobject javaStackState) {
+static jobjectArray Throwable_nativeGetStackTrace(JNIEnv* env, jclass, jobject javaStackState) {
   if (javaStackState == NULL) {
       return NULL;
   }
   return Thread::InternalStackTraceToStackTraceElementArray(env, javaStackState);
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(Throwable, nativeFillInStackTrace, "()Ljava/lang/Object;"),
   NATIVE_METHOD(Throwable, nativeGetStackTrace, "(Ljava/lang/Object;)[Ljava/lang/StackTraceElement;"),
 };
 
-}  // namespace
-
 void register_java_lang_Throwable(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/Throwable", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_VMClassLoader.cc b/src/java_lang_VMClassLoader.cc
index 9d2e2a8..1bb2e63 100644
--- a/src/java_lang_VMClassLoader.cc
+++ b/src/java_lang_VMClassLoader.cc
@@ -23,9 +23,7 @@
 
 namespace art {
 
-namespace {
-
-jclass VMClassLoader_findLoadedClass(JNIEnv* env, jclass, jobject javaLoader, jstring javaName) {
+static jclass VMClassLoader_findLoadedClass(JNIEnv* env, jclass, jobject javaLoader, jstring javaName) {
   ClassLoader* loader = Decode<ClassLoader*>(env, javaLoader);
   ScopedUtfChars name(env, javaName);
   if (name.c_str() == NULL) {
@@ -43,7 +41,7 @@
   }
 }
 
-jint VMClassLoader_getBootClassPathSize(JNIEnv* env, jclass) {
+static jint VMClassLoader_getBootClassPathSize(JNIEnv* env, jclass) {
   return Runtime::Current()->GetClassLinker()->GetBootClassPath().size();
 }
 
@@ -60,7 +58,7 @@
  * with '/'); if it's not we'd need to make it absolute as part of forming
  * the URL string.
  */
-jstring VMClassLoader_getBootClassPathResource(JNIEnv* env, jclass, jstring javaName, jint index) {
+static jstring VMClassLoader_getBootClassPathResource(JNIEnv* env, jclass, jstring javaName, jint index) {
   ScopedUtfChars name(env, javaName);
   if (name.c_str() == NULL) {
     return NULL;
@@ -92,8 +90,6 @@
   NATIVE_METHOD(VMClassLoader, getBootClassPathSize, "()I"),
 };
 
-}  // namespace
-
 void register_java_lang_VMClassLoader(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/VMClassLoader", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_reflect_Array.cc b/src/java_lang_reflect_Array.cc
index 3bf2680..4a5f797 100644
--- a/src/java_lang_reflect_Array.cc
+++ b/src/java_lang_reflect_Array.cc
@@ -23,12 +23,9 @@
 
 namespace art {
 
-namespace {
-
-
 // Recursively create an array with multiple dimensions.  Elements may be
 // Objects or primitive types.
-Array* CreateMultiArray(Class* array_class, int current_dimension, IntArray* dimensions) {
+static Array* CreateMultiArray(Class* array_class, int current_dimension, IntArray* dimensions) {
   int32_t array_length = dimensions->Get(current_dimension++);
   SirtRef<Array> new_array(Array::Alloc(array_class, array_length));
   if (new_array.get() == NULL) {
@@ -72,7 +69,7 @@
 // easiest way to deal with that is to create the full name once and then
 // subtract pieces off.  Besides, we want to start with the outermost
 // piece and work our way in.
-jobject Array_createMultiArray(JNIEnv* env, jclass, jclass javaElementClass, jobject javaDimArray) {
+static jobject Array_createMultiArray(JNIEnv* env, jclass, jclass javaElementClass, jobject javaDimArray) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   DCHECK(javaElementClass != NULL);
   Class* element_class = Decode<Class*>(env, javaElementClass);
@@ -120,8 +117,7 @@
   return AddLocalReference<jobject>(env, new_array);
 }
 
-jobject Array_createObjectArray(JNIEnv* env, jclass, jclass javaElementClass, jint length)
-{
+static jobject Array_createObjectArray(JNIEnv* env, jclass, jclass javaElementClass, jint length) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   DCHECK(javaElementClass != NULL);
   Class* element_class = Decode<Class*>(env, javaElementClass);
@@ -153,8 +149,6 @@
   NATIVE_METHOD(Array, createObjectArray, "(Ljava/lang/Class;I)Ljava/lang/Object;"),
 };
 
-}  // namespace
-
 void register_java_lang_reflect_Array(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/reflect/Array", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_reflect_Constructor.cc b/src/java_lang_reflect_Constructor.cc
index 36481f7..c908bb7 100644
--- a/src/java_lang_reflect_Constructor.cc
+++ b/src/java_lang_reflect_Constructor.cc
@@ -24,8 +24,6 @@
 
 namespace art {
 
-namespace {
-
 /*
  * We get here through Constructor.newInstance().  The Constructor object
  * would not be available if the constructor weren't public (per the
@@ -33,7 +31,7 @@
  * check.  We can also safely assume the constructor isn't associated
  * with an interface, array, or primitive class.
  */
-jobject Constructor_newInstance(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs) {
+static jobject Constructor_newInstance(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Method* m = Decode<Object*>(env, javaMethod)->AsMethod();
   Class* c = m->GetDeclaringClass();
@@ -64,8 +62,6 @@
   NATIVE_METHOD(Constructor, newInstance, "([Ljava/lang/Object;)Ljava/lang/Object;"),
 };
 
-}  // namespace
-
 void register_java_lang_reflect_Constructor(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/reflect/Constructor", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_reflect_Field.cc b/src/java_lang_reflect_Field.cc
index fc1ea4e..d1b40f3 100644
--- a/src/java_lang_reflect_Field.cc
+++ b/src/java_lang_reflect_Field.cc
@@ -24,9 +24,7 @@
 
 namespace art {
 
-namespace {
-
-bool GetFieldValue(Object* o, Field* f, JValue& value, bool allow_references) {
+static bool GetFieldValue(Object* o, Field* f, JValue& value, bool allow_references) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   switch (FieldHelper(f).GetTypeAsPrimitiveType()) {
   case Primitive::kPrimBoolean:
@@ -69,7 +67,7 @@
   return false;
 }
 
-bool CheckReceiver(JNIEnv* env, jobject javaObj, Field* f, Object*& o) {
+static bool CheckReceiver(JNIEnv* env, jobject javaObj, Field* f, Object*& o) {
   if (f->IsStatic()) {
     o = NULL;
     return true;
@@ -83,7 +81,7 @@
   return true;
 }
 
-jobject Field_get(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jobject Field_get(JNIEnv* env, jobject javaField, jobject javaObj) {
   Field* f = DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
   if (!CheckReceiver(env, javaObj, f, o)) {
@@ -100,7 +98,7 @@
   return AddLocalReference<jobject>(env, value.l);
 }
 
-JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char dst_descriptor) {
+static JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char dst_descriptor) {
   Field* f = DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
   if (!CheckReceiver(env, javaObj, f, o)) {
@@ -123,39 +121,39 @@
   return wide_value;
 }
 
-jboolean Field_getBoolean(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jboolean Field_getBoolean(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'Z').z;
 }
 
-jbyte Field_getByte(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jbyte Field_getByte(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'B').b;
 }
 
-jchar Field_getChar(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jchar Field_getChar(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'C').c;
 }
 
-jdouble Field_getDouble(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jdouble Field_getDouble(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'D').d;
 }
 
-jfloat Field_getFloat(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jfloat Field_getFloat(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'F').f;
 }
 
-jint Field_getInt(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jint Field_getInt(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'I').i;
 }
 
-jlong Field_getLong(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jlong Field_getLong(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'J').j;
 }
 
-jshort Field_getShort(JNIEnv* env, jobject javaField, jobject javaObj) {
+static jshort Field_getShort(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'S').s;
 }
 
-void SetFieldValue(Object* o, Field* f, const JValue& new_value, bool allow_references) {
+static void SetFieldValue(Object* o, Field* f, const JValue& new_value, bool allow_references) {
   switch (FieldHelper(f).GetTypeAsPrimitiveType()) {
   case Primitive::kPrimBoolean:
     f->SetBoolean(o, new_value.z);
@@ -201,7 +199,7 @@
   }
 }
 
-void Field_set(JNIEnv* env, jobject javaField, jobject javaObj, jobject javaValue) {
+static void Field_set(JNIEnv* env, jobject javaField, jobject javaObj, jobject javaValue) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Field* f = DecodeField(env->FromReflectedField(javaField));
 
@@ -221,8 +219,8 @@
   SetFieldValue(o, f, unboxed_value, true);
 }
 
-void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char src_descriptor,
-                       const JValue& new_value) {
+static void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char src_descriptor,
+                              const JValue& new_value) {
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Field* f = DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
@@ -248,49 +246,49 @@
   SetFieldValue(o, f, wide_value, false);
 }
 
-void Field_setBoolean(JNIEnv* env, jobject javaField, jobject javaObj, jboolean value) {
+static void Field_setBoolean(JNIEnv* env, jobject javaField, jobject javaObj, jboolean value) {
   JValue v = { 0 };
   v.z = value;
   SetPrimitiveField(env, javaField, javaObj, 'Z', v);
 }
 
-void Field_setByte(JNIEnv* env, jobject javaField, jobject javaObj, jbyte value) {
+static void Field_setByte(JNIEnv* env, jobject javaField, jobject javaObj, jbyte value) {
   JValue v = { 0 };
   v.b = value;
   SetPrimitiveField(env, javaField, javaObj, 'B', v);
 }
 
-void Field_setChar(JNIEnv* env, jobject javaField, jobject javaObj, jchar value) {
+static void Field_setChar(JNIEnv* env, jobject javaField, jobject javaObj, jchar value) {
   JValue v = { 0 };
   v.c = value;
   SetPrimitiveField(env, javaField, javaObj, 'C', v);
 }
 
-void Field_setDouble(JNIEnv* env, jobject javaField, jobject javaObj, jdouble value) {
+static void Field_setDouble(JNIEnv* env, jobject javaField, jobject javaObj, jdouble value) {
   JValue v = { 0 };
   v.d = value;
   SetPrimitiveField(env, javaField, javaObj, 'D', v);
 }
 
-void Field_setFloat(JNIEnv* env, jobject javaField, jobject javaObj, jfloat value) {
+static void Field_setFloat(JNIEnv* env, jobject javaField, jobject javaObj, jfloat value) {
   JValue v = { 0 };
   v.f = value;
   SetPrimitiveField(env, javaField, javaObj, 'F', v);
 }
 
-void Field_setInt(JNIEnv* env, jobject javaField, jobject javaObj, jint value) {
+static void Field_setInt(JNIEnv* env, jobject javaField, jobject javaObj, jint value) {
   JValue v = { 0 };
   v.i = value;
   SetPrimitiveField(env, javaField, javaObj, 'I', v);
 }
 
-void Field_setLong(JNIEnv* env, jobject javaField, jobject javaObj, jlong value) {
+static void Field_setLong(JNIEnv* env, jobject javaField, jobject javaObj, jlong value) {
   JValue v = { 0 };
   v.j = value;
   SetPrimitiveField(env, javaField, javaObj, 'J', v);
 }
 
-void Field_setShort(JNIEnv* env, jobject javaField, jobject javaObj, jshort value) {
+static void Field_setShort(JNIEnv* env, jobject javaField, jobject javaObj, jshort value) {
   JValue v = { 0 };
   v.s = value;
   SetPrimitiveField(env, javaField, javaObj, 'S', v);
@@ -317,8 +315,6 @@
   NATIVE_METHOD(Field, setShort,   "(Ljava/lang/Object;S)V"),
 };
 
-}  // namespace
-
 void register_java_lang_reflect_Field(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/reflect/Field", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_reflect_Method.cc b/src/java_lang_reflect_Method.cc
index 7049eff..d9006dc 100644
--- a/src/java_lang_reflect_Method.cc
+++ b/src/java_lang_reflect_Method.cc
@@ -24,13 +24,11 @@
 
 namespace art {
 
-namespace {
-
-jobject Method_invoke(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs) {
+static jobject Method_invoke(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs) {
   return InvokeMethod(env, javaMethod, javaReceiver, javaArgs);
 }
 
-jobject Method_getExceptionTypesNative(JNIEnv* env, jobject javaMethod) {
+static jobject Method_getExceptionTypesNative(JNIEnv* env, jobject javaMethod) {
   Method* proxy_method = Decode<Object*>(env, javaMethod)->AsMethod();
   CHECK(proxy_method->GetDeclaringClass()->IsProxyClass());
   SynthesizedProxyClass* proxy_class =
@@ -50,7 +48,7 @@
   return AddLocalReference<jobject>(env, declared_exceptions->Clone());
 }
 
-jobject Method_findOverriddenMethodNative(JNIEnv* env, jobject javaMethod) {
+static jobject Method_findOverriddenMethodNative(JNIEnv* env, jobject javaMethod) {
   Method* method = Decode<Object*>(env, javaMethod)->AsMethod();
   return AddLocalReference<jobject>(env, method->FindOverriddenMethod());
 }
@@ -61,8 +59,6 @@
   NATIVE_METHOD(Method, findOverriddenMethodNative, "()Ljava/lang/reflect/Method;"),
 };
 
-}  // namespace
-
 void register_java_lang_reflect_Method(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/reflect/Method", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_lang_reflect_Proxy.cc b/src/java_lang_reflect_Proxy.cc
index 28fe514..7bc3e44 100644
--- a/src/java_lang_reflect_Proxy.cc
+++ b/src/java_lang_reflect_Proxy.cc
@@ -22,8 +22,6 @@
 
 namespace art {
 
-namespace {
-
 static jclass Proxy_generateProxy(JNIEnv* env, jclass, jstring javaName, jobjectArray javaInterfaces, jobject javaLoader, jobjectArray javaMethods, jobjectArray javaThrows) {
   // Allocates Class so transition thread state to runnable
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
@@ -37,12 +35,10 @@
   return AddLocalReference<jclass>(env, result);
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(Proxy, generateProxy, "(Ljava/lang/String;[Ljava/lang/Class;Ljava/lang/ClassLoader;[Ljava/lang/reflect/Method;[[Ljava/lang/Class;)Ljava/lang/Class;"),
 };
 
-}  // namespace
-
 void register_java_lang_reflect_Proxy(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/lang/reflect/Proxy", gMethods, NELEM(gMethods));
 }
diff --git a/src/java_util_concurrent_atomic_AtomicLong.cc b/src/java_util_concurrent_atomic_AtomicLong.cc
index eda98ac..118b9e4 100644
--- a/src/java_util_concurrent_atomic_AtomicLong.cc
+++ b/src/java_util_concurrent_atomic_AtomicLong.cc
@@ -21,18 +21,14 @@
 
 namespace art {
 
-namespace {
-
-jboolean AtomicLong_VMSupportsCS8(JNIEnv*, jclass) {
+static jboolean AtomicLong_VMSupportsCS8(JNIEnv*, jclass) {
   return JNI_TRUE;
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(AtomicLong, VMSupportsCS8, "()Z"),
 };
 
-}  // namespace
-
 void register_java_util_concurrent_atomic_AtomicLong(JNIEnv* env) {
   jniRegisterNativeMethods(env, "java/util/concurrent/atomic/AtomicLong", gMethods, NELEM(gMethods));
 }
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 64d8203..7d273ac 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -238,9 +238,7 @@
   UniquePtr<JValue[]> large_arg_array_;
 };
 
-namespace {
-
-jweak AddWeakGlobalReference(ScopedJniThreadState& ts, Object* obj) {
+static jweak AddWeakGlobalReference(ScopedJniThreadState& ts, Object* obj) {
   if (obj == NULL) {
     return NULL;
   }
@@ -253,7 +251,7 @@
 
 // For internal use.
 template<typename T>
-T Decode(ScopedJniThreadState& ts, jobject obj) {
+static T Decode(ScopedJniThreadState& ts, jobject obj) {
   return reinterpret_cast<T>(ts.Self()->DecodeJObject(obj));
 }
 
@@ -412,14 +410,14 @@
 }
 
 template<typename JniT, typename ArtT>
-JniT NewPrimitiveArray(ScopedJniThreadState& ts, jsize length) {
+static JniT NewPrimitiveArray(ScopedJniThreadState& ts, jsize length) {
   CHECK_GE(length, 0); // TODO: ReportJniError
   ArtT* result = ArtT::Alloc(length);
   return AddLocalReference<JniT>(ts.Env(), result);
 }
 
 template <typename ArrayT, typename CArrayT, typename ArtArrayT>
-CArrayT GetPrimitiveArray(ScopedJniThreadState& ts, ArrayT java_array, jboolean* is_copy) {
+static CArrayT GetPrimitiveArray(ScopedJniThreadState& ts, ArrayT java_array, jboolean* is_copy) {
   ArtArrayT* array = Decode<ArtArrayT*>(ts, java_array);
   PinPrimitiveArray(ts, array);
   if (is_copy != NULL) {
@@ -429,7 +427,7 @@
 }
 
 template <typename ArrayT>
-void ReleasePrimitiveArray(ScopedJniThreadState& ts, ArrayT java_array, jint mode) {
+static void ReleasePrimitiveArray(ScopedJniThreadState& ts, ArrayT java_array, jint mode) {
   if (mode != JNI_COMMIT) {
     Array* array = Decode<Array*>(ts, java_array);
     UnpinPrimitiveArray(ts, array);
@@ -449,7 +447,7 @@
 }
 
 template <typename JavaArrayT, typename JavaT, typename ArrayT>
-void GetPrimitiveArrayRegion(ScopedJniThreadState& ts, JavaArrayT java_array, jsize start, jsize length, JavaT* buf) {
+static void GetPrimitiveArrayRegion(ScopedJniThreadState& ts, JavaArrayT java_array, jsize start, jsize length, JavaT* buf) {
   ArrayT* array = Decode<ArrayT*>(ts, java_array);
   if (start < 0 || length < 0 || start + length > array->GetLength()) {
     ThrowAIOOBE(ts, array, start, length, "src");
@@ -460,7 +458,7 @@
 }
 
 template <typename JavaArrayT, typename JavaT, typename ArrayT>
-void SetPrimitiveArrayRegion(ScopedJniThreadState& ts, JavaArrayT java_array, jsize start, jsize length, const JavaT* buf) {
+static void SetPrimitiveArrayRegion(ScopedJniThreadState& ts, JavaArrayT java_array, jsize start, jsize length, const JavaT* buf) {
   ArrayT* array = Decode<ArrayT*>(ts, java_array);
   if (start < 0 || length < 0 || start + length > array->GetLength()) {
     ThrowAIOOBE(ts, array, start, length, "dst");
@@ -612,8 +610,6 @@
   JNI_OnLoadState jni_on_load_result_;
 };
 
-}  // namespace
-
 // This exists mainly to keep implementation details out of the header file.
 class Libraries {
  public:
diff --git a/src/org_apache_harmony_dalvik_ddmc_DdmServer.cc b/src/org_apache_harmony_dalvik_ddmc_DdmServer.cc
index b46ee1f..42568d0 100644
--- a/src/org_apache_harmony_dalvik_ddmc_DdmServer.cc
+++ b/src/org_apache_harmony_dalvik_ddmc_DdmServer.cc
@@ -22,8 +22,6 @@
 
 namespace art {
 
-namespace {
-
 static void DdmServer_nativeSendChunk(JNIEnv* env, jclass, jint type,
                                       jbyteArray javaData, jint offset, jint length)
 {
@@ -36,8 +34,6 @@
   NATIVE_METHOD(DdmServer, nativeSendChunk, "(I[BII)V"),
 };
 
-}  // namespace
-
 void register_org_apache_harmony_dalvik_ddmc_DdmServer(JNIEnv* env) {
   jniRegisterNativeMethods(env, "org/apache/harmony/dalvik/ddmc/DdmServer", gMethods, NELEM(gMethods));
 }
diff --git a/src/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc b/src/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
index bf356dc..369abd4 100644
--- a/src/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
+++ b/src/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
@@ -26,8 +26,6 @@
 
 namespace art {
 
-namespace {
-
 static void DdmVmInternal_enableRecentAllocations(JNIEnv* env, jclass, jboolean enable) {
   Dbg::SetAllocTrackingEnabled(enable);
 }
@@ -163,8 +161,6 @@
   NATIVE_METHOD(DdmVmInternal, threadNotify, "(Z)V"),
 };
 
-}  // namespace
-
 void register_org_apache_harmony_dalvik_ddmc_DdmVmInternal(JNIEnv* env) {
   jniRegisterNativeMethods(env, "org/apache/harmony/dalvik/ddmc/DdmVmInternal", gMethods, NELEM(gMethods));
 }
diff --git a/src/sun_misc_Unsafe.cc b/src/sun_misc_Unsafe.cc
index a561690..d5d7444 100644
--- a/src/sun_misc_Unsafe.cc
+++ b/src/sun_misc_Unsafe.cc
@@ -21,28 +21,26 @@
 
 namespace art {
 
-namespace {
-
-jlong Unsafe_objectFieldOffset0(JNIEnv* env, jclass, jobject javaField) {
+static jlong Unsafe_objectFieldOffset0(JNIEnv* env, jclass, jobject javaField) {
   // TODO: move to Java code
   jfieldID fid = env->FromReflectedField(javaField);
   Field* field = DecodeField(fid);
   return field->GetOffset().Int32Value();
 }
 
-jint Unsafe_arrayBaseOffset0(JNIEnv* env, jclass, jclass javaArrayClass) {
+static jint Unsafe_arrayBaseOffset0(JNIEnv* env, jclass, jclass javaArrayClass) {
   // TODO: move to Java code
   ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
   Class* array_class = Decode<Class*>(env, javaArrayClass);
   return Array::DataOffset(array_class->GetComponentSize()).Int32Value();
 }
 
-jint Unsafe_arrayIndexScale0(JNIEnv* env, jclass, jclass javaClass) {
+static jint Unsafe_arrayIndexScale0(JNIEnv* env, jclass, jclass javaClass) {
   Class* c = Decode<Class*>(env, javaClass);
   return c->GetComponentSize();
 }
 
-jboolean Unsafe_compareAndSwapInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint expectedValue, jint newValue) {
+static jboolean Unsafe_compareAndSwapInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint expectedValue, jint newValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
@@ -51,7 +49,7 @@
   return (result == 0);
 }
 
-jboolean Unsafe_compareAndSwapLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong expectedValue, jlong newValue) {
+static jboolean Unsafe_compareAndSwapLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong expectedValue, jlong newValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   volatile int64_t* address = reinterpret_cast<volatile int64_t*>(raw_addr);
@@ -60,7 +58,7 @@
   return (result == 0);
 }
 
-jboolean Unsafe_compareAndSwapObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaExpectedValue, jobject javaNewValue) {
+static jboolean Unsafe_compareAndSwapObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaExpectedValue, jobject javaNewValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   Object* expectedValue = Decode<Object*>(env, javaExpectedValue);
   Object* newValue = Decode<Object*>(env, javaNewValue);
@@ -75,97 +73,96 @@
   return (result == 0);
 }
 
-jint Unsafe_getInt(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+static jint Unsafe_getInt(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
   Object* obj = Decode<Object*>(env, javaObj);
   return obj->GetField32(MemberOffset(offset), false);
 }
 
-jint Unsafe_getIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+static jint Unsafe_getIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
   Object* obj = Decode<Object*>(env, javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
   return android_atomic_acquire_load(address);
 }
 
-void Unsafe_putInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
+static void Unsafe_putInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   obj->SetField32(MemberOffset(offset), newValue, false);
 }
 
-void Unsafe_putIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
+static void Unsafe_putIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
   android_atomic_release_store(newValue, address);
 }
 
-void Unsafe_putOrderedInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
+static void Unsafe_putOrderedInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   ANDROID_MEMBAR_STORE();
   obj->SetField32(MemberOffset(offset), newValue, false);
 }
 
-jlong Unsafe_getLong(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+static jlong Unsafe_getLong(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
   Object* obj = Decode<Object*>(env, javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   int64_t* address = reinterpret_cast<int64_t*>(raw_addr);
   return *address;
 }
 
-jlong Unsafe_getLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+static jlong Unsafe_getLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
   Object* obj = Decode<Object*>(env, javaObj);
   return obj->GetField64(MemberOffset(offset), true);
 }
 
-void Unsafe_putLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
+static void Unsafe_putLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   obj->SetField64(MemberOffset(offset), newValue, false);
 }
 
-void Unsafe_putLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
+static void Unsafe_putLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   obj->SetField64(MemberOffset(offset), newValue, true);
 }
 
-void Unsafe_putOrderedLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
+static void Unsafe_putOrderedLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   ANDROID_MEMBAR_STORE();
   obj->SetField64(MemberOffset(offset), newValue, false);
 }
 
-jobject Unsafe_getObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+static jobject Unsafe_getObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
   Object* obj = Decode<Object*>(env, javaObj);
   Object* value = obj->GetFieldObject<Object*>(MemberOffset(offset), true);
   return AddLocalReference<jobject>(env, value);
 }
 
-jobject Unsafe_getObject(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
+static jobject Unsafe_getObject(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
   Object* obj = Decode<Object*>(env, javaObj);
   Object* value = obj->GetFieldObject<Object*>(MemberOffset(offset), false);
   return AddLocalReference<jobject>(env, value);
 }
 
-void Unsafe_putObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
+static void Unsafe_putObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   Object* newValue = Decode<Object*>(env, javaNewValue);
   obj->SetFieldObject(MemberOffset(offset), newValue, false);
 }
 
-void Unsafe_putObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
+static void Unsafe_putObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   Object* newValue = Decode<Object*>(env, javaNewValue);
   obj->SetFieldObject(MemberOffset(offset), newValue, true);
 }
 
-
-void Unsafe_putOrderedObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
+static void Unsafe_putOrderedObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
   Object* obj = Decode<Object*>(env, javaObj);
   Object* newValue = Decode<Object*>(env, javaNewValue);
   ANDROID_MEMBAR_STORE();
   obj->SetFieldObject(MemberOffset(offset), newValue, false);
 }
 
-JNINativeMethod gMethods[] = {
+static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(Unsafe, objectFieldOffset0, "(Ljava/lang/reflect/Field;)J"),
   NATIVE_METHOD(Unsafe, arrayBaseOffset0, "(Ljava/lang/Class;)I"),
   NATIVE_METHOD(Unsafe, arrayIndexScale0, "(Ljava/lang/Class;)I"),
@@ -189,8 +186,6 @@
   NATIVE_METHOD(Unsafe, putOrderedObject, "(Ljava/lang/Object;JLjava/lang/Object;)V"),
 };
 
-}  // namespace
-
 void register_sun_misc_Unsafe(JNIEnv* env) {
   jniRegisterNativeMethods(env, "sun/misc/Unsafe", gMethods, NELEM(gMethods));
 }
diff --git a/src/utils.cc b/src/utils.cc
index 4895fe5..26fe605 100644
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -133,6 +133,17 @@
 #endif
 }
 
+uint64_t ThreadCpuNanoTime() {
+#if defined(HAVE_POSIX_CLOCKS)
+  struct timespec now;
+  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &now);
+  return static_cast<uint64_t>(now.tv_sec) * 1000000000LL + now.tv_nsec;
+#else
+  UNIMPLEMENTED(WARNING);
+  return -1;
+#endif
+}
+
 std::string PrettyDescriptor(const String* java_descriptor) {
   if (java_descriptor == NULL) {
     return "null";
diff --git a/src/utils.h b/src/utils.h
index e774a3b..cdd8fad 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -240,18 +240,21 @@
 // Returns the current date in ISO yyyy-mm-dd hh:mm:ss format.
 std::string GetIsoDate();
 
-// Returns the current time in milliseconds (using the POSIX CLOCK_MONOTONIC).
+// Returns the monotonic time since some unspecified starting point in milliseconds.
 uint64_t MilliTime();
 
-// Returns the current time in microseconds (using the POSIX CLOCK_MONOTONIC).
+// Returns the monotonic time since some unspecified starting point in microseconds.
 uint64_t MicroTime();
 
-// Returns the current time in nanoseconds (using the POSIX CLOCK_MONOTONIC).
+// Returns the monotonic time since some unspecified starting point in nanoseconds.
 uint64_t NanoTime();
 
-// Returns the current time in microseconds (using the POSIX CLOCK_THREAD_CPUTIME_ID).
+// Returns the thread-specific CPU-time clock in microseconds or -1 if unavailable.
 uint64_t ThreadCpuMicroTime();
 
+// Returns the thread-specific CPU-time clock in nanoseconds or -1 if unavailable.
+uint64_t ThreadCpuNanoTime();
+
 // Converts the given number of nanoseconds to milliseconds.
 static inline uint64_t NsToMs(uint64_t ns) {
   return ns / 1000 / 1000;