diff --git a/src/class_linker.cc b/src/class_linker.cc
index 97a75ac..b495e3e 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -1015,8 +1015,8 @@
     klass->SetDescriptor(intern_table_->InternStrong(descriptor));
   }
   uint32_t access_flags = dex_class_def.access_flags_;
-  // Make sure there aren't any "bonus" flags set, since we use them for runtime state.
-  CHECK_EQ(access_flags & ~kAccClassFlagsMask, 0U);
+  // Make sure that none of our runtime-only flags are set.
+  CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
   klass->SetAccessFlags(access_flags);
   klass->SetClassLoader(class_loader);
   DCHECK(klass->GetPrimitiveType() == Class::kPrimNot);
diff --git a/src/java_lang_reflect_Field.cc b/src/java_lang_reflect_Field.cc
index 2937241..7d43b2e 100644
--- a/src/java_lang_reflect_Field.cc
+++ b/src/java_lang_reflect_Field.cc
@@ -26,7 +26,7 @@
 namespace {
 
 jint Field_getFieldModifiers(JNIEnv* env, jobject jfield, jclass javaDeclaringClass, jint slot) {
-  return Decode<Object*>(env, jfield)->AsField()->GetAccessFlags() & kAccFieldFlagsMask;
+  return Decode<Object*>(env, jfield)->AsField()->GetAccessFlags() & kAccJavaFlagsMask;
 }
 
 bool GetFieldValue(Object* o, Field* f, JValue& value, bool allow_references) {
@@ -85,7 +85,7 @@
   return true;
 }
 
-JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jchar targetDescriptor) {
+JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jchar dst_descriptor) {
   Field* f = DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
   if (!CheckReceiver(env, javaObj, javaDeclaringClass, f, o)) {
@@ -100,43 +100,43 @@
 
   // Widen it if necessary (and possible).
   JValue wide_value;
-  Class* targetType = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(targetDescriptor);
-  if (!ConvertPrimitiveValue(f->GetType(), targetType, field_value, wide_value)) {
+  Class* dst_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(dst_descriptor);
+  if (!ConvertPrimitiveValue(f->GetType(), dst_type, field_value, wide_value)) {
     return JValue();
   }
   return wide_value;
 }
 
-jbyte Field_getBField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor).b;
+jbyte Field_getBField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
+  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).b;
 }
 
-jchar Field_getCField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor).c;
+jchar Field_getCField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
+  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).c;
 }
 
-jdouble Field_getDField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor).d;
+jdouble Field_getDField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
+  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).d;
 }
 
-jfloat Field_getFField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor).f;
+jfloat Field_getFField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
+  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).f;
 }
 
-jint Field_getIField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor).i;
+jint Field_getIField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
+  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).i;
 }
 
-jlong Field_getJField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor).j;
+jlong Field_getJField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
+  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).j;
 }
 
-jshort Field_getSField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor).s;
+jshort Field_getSField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
+  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).s;
 }
 
-jboolean Field_getZField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor) {
-  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor).z;
+jboolean Field_getZField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar dst_descriptor) {
+  return GetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, dst_descriptor).z;
 }
 
 void SetFieldValue(Object* o, Field* f, const JValue& new_value, bool allow_references) {
@@ -185,7 +185,7 @@
   }
 }
 
-void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jchar targetDescriptor, const JValue& new_value) {
+void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jchar src_descriptor, const JValue& new_value) {
   Field* f = DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
   if (!CheckReceiver(env, javaObj, javaDeclaringClass, f, o)) {
@@ -194,8 +194,8 @@
 
   // Widen the value if necessary (and possible).
   JValue wide_value;
-  Class* targetType = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(targetDescriptor);
-  if (!ConvertPrimitiveValue(f->GetType(), targetType, new_value, wide_value)) {
+  Class* src_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(src_descriptor);
+  if (!ConvertPrimitiveValue(src_type, f->GetType(), new_value, wide_value)) {
     return;
   }
 
@@ -203,52 +203,52 @@
   SetFieldValue(o, f, wide_value, false);
 }
 
-void Field_setBField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor, jbyte value) {
+void Field_setBField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jbyte value) {
   JValue v = { 0 };
   v.b = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
 }
 
-void Field_setCField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor, jchar value) {
+void Field_setCField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jchar value) {
   JValue v = { 0 };
   v.c = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
 }
 
-void Field_setDField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor, jdouble value) {
+void Field_setDField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jdouble value) {
   JValue v = { 0 };
   v.d = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
 }
 
-void Field_setFField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor, jfloat value) {
+void Field_setFField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jfloat value) {
   JValue v = { 0 };
   v.f = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
 }
 
-void Field_setIField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor, jint value) {
+void Field_setIField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jint value) {
   JValue v = { 0 };
   v.i = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
 }
 
-void Field_setJField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor, jlong value) {
+void Field_setJField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jlong value) {
   JValue v = { 0 };
   v.j = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
 }
 
-void Field_setSField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor, jshort value) {
+void Field_setSField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jshort value) {
   JValue v = { 0 };
   v.s = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
 }
 
-void Field_setZField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar targetDescriptor, jboolean value) {
+void Field_setZField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jchar src_descriptor, jboolean value) {
   JValue v = { 0 };
   v.z = value;
-  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, targetDescriptor, v);
+  SetPrimitiveField(env, javaField, javaObj, javaDeclaringClass, src_descriptor, v);
 }
 
 void Field_setField(JNIEnv* env, jobject javaField, jobject javaObj, jclass javaDeclaringClass, jclass, jint, jboolean, jobject javaValue) {
diff --git a/src/java_lang_reflect_Method.cc b/src/java_lang_reflect_Method.cc
index dc3f314..e36078f 100644
--- a/src/java_lang_reflect_Method.cc
+++ b/src/java_lang_reflect_Method.cc
@@ -35,7 +35,8 @@
   if ((access_flags & kAccDeclaredSynchronized) != 0) {
     access_flags |= kAccSynchronized;
   }
-  return access_flags & kAccMethodFlagsMask;
+
+  return access_flags & kAccJavaFlagsMask;
 }
 
 jint Method_getProtoIndex(JNIEnv* env, jclass, jclass javaDeclaringClass, jobject jmethod, jint slot) {
diff --git a/src/object.h b/src/object.h
index e5036e6..4b2b54a 100644
--- a/src/object.h
+++ b/src/object.h
@@ -77,7 +77,7 @@
 static const uint32_t kAccStatic = 0x0008;  // field, method, ic
 static const uint32_t kAccFinal = 0x0010;  // class, field, method, ic
 static const uint32_t kAccSynchronized = 0x0020;  // method (only allowed on natives)
-static const uint32_t kAccSuper = 0x0020;  // class (not used in Dalvik)
+static const uint32_t kAccSuper = 0x0020;  // class (not used in dex)
 static const uint32_t kAccVolatile = 0x0040;  // field
 static const uint32_t kAccBridge = 0x0040;  // method (1.5)
 static const uint32_t kAccTransient = 0x0080;  // field
@@ -94,44 +94,9 @@
 
 static const uint32_t kAccJavaFlagsMask = 0xffff;  // bits set from Java sources (low 16)
 
-static const uint32_t kAccConstructor = 0x00010000;  // method (Dalvik only)
-static const uint32_t kAccDeclaredSynchronized = 0x00020000;  // method (Dalvik only)
-static const uint32_t kAccWritable = 0x80000000; // method (Dalvik only)
-
-static const uint32_t kAccClassFlagsMask = (kAccPublic
-                                            | kAccFinal
-                                            | kAccInterface
-                                            | kAccAbstract
-                                            | kAccSynthetic
-                                            | kAccAnnotation
-                                            | kAccEnum);
-static const uint32_t kAccInnerClassFlagsMask = (kAccClassFlagsMask
-                                                 | kAccPrivate
-                                                 | kAccProtected
-                                                 | kAccStatic);
-static const uint32_t kAccFieldFlagsMask = (kAccPublic
-                                            | kAccPrivate
-                                            | kAccProtected
-                                            | kAccStatic
-                                            | kAccFinal
-                                            | kAccVolatile
-                                            | kAccTransient
-                                            | kAccSynthetic
-                                            | kAccEnum);
-static const uint32_t kAccMethodFlagsMask = (kAccPublic
-                                             | kAccPrivate
-                                             | kAccProtected
-                                             | kAccStatic
-                                             | kAccFinal
-                                             | kAccSynchronized
-                                             | kAccBridge
-                                             | kAccVarargs
-                                             | kAccNative
-                                             | kAccAbstract
-                                             | kAccStrict
-                                             | kAccSynthetic
-                                             | kAccConstructor
-                                             | kAccDeclaredSynchronized);
+static const uint32_t kAccConstructor = 0x00010000;  // method (dex only)
+static const uint32_t kAccDeclaredSynchronized = 0x00020000;  // method (dex only)
+static const uint32_t kAccWritable = 0x80000000; // method (dex only)
 
 // Special runtime-only flags.
 // Note: if only kAccClassIsReference is set, we have a soft reference.
diff --git a/test/046-reflect/expected.txt b/test/046-reflect/expected.txt
index 55b0eca..b2bb176 100644
--- a/test/046-reflect/expected.txt
+++ b/test/046-reflect/expected.txt
@@ -81,8 +81,9 @@
  Field type is int
  Access flags are 0x11
   cantTouchThis is 77
-  got expected set-final failure
-  cantTouchThis is now 77
+  setAccessible is always true
+  cantTouchThis is now 99
+  cantTouchThis is now 87
   cantTouchThis is now 88
 cons modifiers=1
 SuperTarget constructor ()V
diff --git a/test/046-reflect/src/Main.java b/test/046-reflect/src/Main.java
index e604979..7b6036b 100644
--- a/test/046-reflect/src/Main.java
+++ b/test/046-reflect/src/Main.java
@@ -272,15 +272,17 @@
             System.out.println("  cantTouchThis is " + intVal);
             try {
                 field.setInt(instance, 99);
-                System.out.println("ERROR: set-final succeeded");
+                System.out.println("  setAccessible is always true");
             } catch (IllegalAccessException iae) {
-                System.out.println("  got expected set-final failure");
+                System.out.println("ERROR: set-final failed");
             }
             intVal = field.getInt(instance);
             System.out.println("  cantTouchThis is now " + intVal);
 
             field.setAccessible(true);
             field.setInt(instance, 87);     // exercise int version
+            intVal = field.getInt(instance);
+            System.out.println("  cantTouchThis is now " + intVal);
             field.set(instance, 88);        // exercise Object version
             intVal = field.getInt(instance);
             System.out.println("  cantTouchThis is now " + intVal);