From 76e3694db07d068d1a5e0ae7088b6f7bff6e9d43 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 16 Mar 2012 13:44:56 -0700
Subject: Clean up the trivial uses of __attribute__((unused)).

My usual objection would be that this leads to breakage, but since we compile
all variants all the time anyway, I think this is probably the better choice.
In particular, it means we can notice when no variant needs the parameter any
more.

Change-Id: Ia7e5c1a58597d9f9ff6f337c3d9cf00ecdf4c208
---
 src/dalvik_system_Zygote.cc |  8 +++++---
 src/mutex.cc                | 17 ++++++++++-------
 src/object.h                |  8 +++++---
 3 files changed, 20 insertions(+), 13 deletions(-)

(limited to 'src')

diff --git a/src/dalvik_system_Zygote.cc b/src/dalvik_system_Zygote.cc
index 3f44109ef7..c46f949b4b 100644
--- a/src/dalvik_system_Zygote.cc
+++ b/src/dalvik_system_Zygote.cc
@@ -175,8 +175,8 @@ static int SetRLimits(JNIEnv* env, jobjectArray javaRlimits) {
   return 0;
 }
 
-static void SetCapabilities(int64_t __attribute__((unused)) permitted, int64_t __attribute__((unused)) effective) {
-#ifdef HAVE_ANDROID_OS
+#if defined(HAVE_ANDROID_OS)
+static void SetCapabilities(int64_t permitted, int64_t effective) {
   struct __user_cap_header_struct capheader;
   struct __user_cap_data_struct capdata;
 
@@ -192,8 +192,10 @@ static void SetCapabilities(int64_t __attribute__((unused)) permitted, int64_t _
   if (capset(&capheader, &capdata) != 0) {
     PLOG(FATAL) << "capset(" << permitted << ", " << effective << ") failed";
   }
-#endif /*HAVE_ANDROID_OS*/
 }
+#else
+static void SetCapabilities(int64_t, int64_t) {}
+#endif
 
 static void EnableDebugFeatures(uint32_t debug_flags) {
   // Must match values in dalvik.system.Zygote.
diff --git a/src/mutex.cc b/src/mutex.cc
index 01aeff495b..b3cf94639f 100644
--- a/src/mutex.cc
+++ b/src/mutex.cc
@@ -27,9 +27,8 @@
 
 namespace art {
 
-static inline void CheckSafeToLockOrUnlock(MutexRank __attribute__((unused)) rank,
-                                           bool __attribute__((unused)) is_locking) {
-#ifndef NDEBUG
+#if !defined(NDBEUG)
+static inline void CheckSafeToLockOrUnlock(MutexRank rank, bool is_locking) {
   if (rank == -1) {
     return;
   }
@@ -37,17 +36,21 @@ static inline void CheckSafeToLockOrUnlock(MutexRank __attribute__((unused)) ran
   if (self != NULL) {
     self->CheckSafeToLockOrUnlock(rank, is_locking);
   }
-#endif
 }
+#else
+static inline void CheckSafeToLockOrUnlock(MutexRank, bool) {}
+#endif
 
-static inline void CheckSafeToWait(MutexRank __attribute__((unused)) rank) {
-#ifndef NDEBUG
+#if !defined(NDEBUG)
+static inline void CheckSafeToWait(MutexRank rank) {
   Thread* self = Thread::Current();
   if (self != NULL) {
     self->CheckSafeToWait(rank);
   }
-#endif
 }
+#else
+static inline void CheckSafeToWait(MutexRank) {}
+#endif
 
 Mutex::Mutex(const char* name, MutexRank rank) : name_(name), rank_(rank) {
   // Like Java, we use recursive mutexes.
diff --git a/src/object.h b/src/object.h
index 0a670ee4c5..a609433c91 100644
--- a/src/object.h
+++ b/src/object.h
@@ -2332,8 +2332,8 @@ inline uint32_t Method::GetDexMethodIndex() const {
   return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_dex_index_), false);
 }
 
-inline void Method::AssertPcIsWithinCode(uintptr_t __attribute__((unused)) pc) const {
-#ifndef NDEBUG
+#if !defined(NDEBUG)
+inline void Method::AssertPcIsWithinCode(uintptr_t pc) const {
   if (IsNative() || IsRuntimeMethod() || IsProxyMethod()) {
     return;
   }
@@ -2346,8 +2346,10 @@ inline void Method::AssertPcIsWithinCode(uintptr_t __attribute__((unused)) pc) c
       << " pc=" << std::hex << pc
       << " code=" << GetCode()
       << " size=" << GetCodeSize();
-#endif
 }
+#else
+inline void Method::AssertPcIsWithinCode(uintptr_t) const {}
+#endif
 
 inline String* Class::GetName() const {
   return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Class, name_), false);
-- 
cgit v1.2.3-59-g8ed1b