Remove anonymous namespaces.
No one likes them and we're pretty inconsistent at using them. We're
much better with 'static'.
Change-Id: I65eeffd0fb60633edca30923af0caedb06a0105d
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 3f57bfc..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;