Merge "Add basic support for object pointer poisoning"
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 678abe0..ecaa4c2 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -2378,6 +2378,7 @@
DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
DCHECK(self != nullptr);
self->AssertNoPendingException();
+ self->PoisonObjectPointers();
if (descriptor[1] == '\0') {
// only the descriptors of primitive types should be 1 character long, also avoid class lookup
// for primitive classes that aren't backed by dex files.
diff --git a/runtime/mirror/obj_ptr.h b/runtime/mirror/obj_ptr.h
new file mode 100644
index 0000000..10378e8
--- /dev/null
+++ b/runtime/mirror/obj_ptr.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_RUNTIME_MIRROR_OBJ_PTR_H_
+#define ART_RUNTIME_MIRROR_OBJ_PTR_H_
+
+#include "base/mutex.h" // For Locks::mutator_lock_.
+#include "globals.h"
+#include "mirror/object_reference.h"
+#include "utils.h"
+
+namespace art {
+namespace mirror {
+
+class Object;
+
+// Value type representing a pointer to a mirror::Object of type MirrorType
+// Pass kPoison as a template boolean for testing in non-debug builds.
+// Note that the functions are not 100% thread safe and may have spurious positive check passes in
+// these cases.
+template<class MirrorType, bool kPoison = kIsDebugBuild>
+class ObjPtr {
+ static constexpr size_t kCookieShift =
+ sizeof(mirror::HeapReference<mirror::Object>) * kBitsPerByte - kObjectAlignmentShift;
+ static constexpr size_t kCookieBits = sizeof(uintptr_t) * kBitsPerByte - kCookieShift;
+ static constexpr uintptr_t kCookieMask = (static_cast<uintptr_t>(1u) << kCookieBits) - 1;
+
+ static_assert(kCookieBits >= kObjectAlignmentShift,
+ "must have a least kObjectAlignmentShift bits");
+
+ public:
+ ALWAYS_INLINE ObjPtr() REQUIRES_SHARED(Locks::mutator_lock_) : reference_(0u) {}
+
+ ALWAYS_INLINE explicit ObjPtr(MirrorType* ptr) REQUIRES_SHARED(Locks::mutator_lock_)
+ : reference_(Encode(ptr)) {}
+
+ ALWAYS_INLINE explicit ObjPtr(const ObjPtr& other) REQUIRES_SHARED(Locks::mutator_lock_)
+ = default;
+
+ ALWAYS_INLINE ObjPtr& operator=(const ObjPtr& other) {
+ reference_ = other.reference_;
+ return *this;
+ }
+
+ ALWAYS_INLINE ObjPtr& operator=(MirrorType* ptr) REQUIRES_SHARED(Locks::mutator_lock_) {
+ Assign(ptr);
+ return *this;
+ }
+
+ ALWAYS_INLINE void Assign(MirrorType* ptr) REQUIRES_SHARED(Locks::mutator_lock_) {
+ reference_ = Encode(ptr);
+ }
+
+ ALWAYS_INLINE MirrorType* operator->() const REQUIRES_SHARED(Locks::mutator_lock_) {
+ return Get();
+ }
+
+ ALWAYS_INLINE MirrorType* Get() const REQUIRES_SHARED(Locks::mutator_lock_) {
+ return Decode();
+ }
+
+ ALWAYS_INLINE bool IsNull() const {
+ return reference_ == 0;
+ }
+
+ ALWAYS_INLINE bool IsValid() const REQUIRES_SHARED(Locks::mutator_lock_) {
+ if (!kPoison || IsNull()) {
+ return true;
+ }
+ return GetCookie() == TrimCookie(Thread::Current()->GetPoisonObjectCookie());
+ }
+
+ ALWAYS_INLINE void AssertValid() const REQUIRES_SHARED(Locks::mutator_lock_) {
+ if (kPoison) {
+ CHECK(IsValid()) << "Stale object pointer, expected cookie "
+ << TrimCookie(Thread::Current()->GetPoisonObjectCookie()) << " but got " << GetCookie();
+ }
+ }
+
+ ALWAYS_INLINE bool operator==(const ObjPtr& ptr) const REQUIRES_SHARED(Locks::mutator_lock_) {
+ return Decode() == ptr.Decode();
+ }
+
+ ALWAYS_INLINE bool operator==(const MirrorType* ptr) const REQUIRES_SHARED(Locks::mutator_lock_) {
+ return Decode() == ptr;
+ }
+
+ ALWAYS_INLINE bool operator==(std::nullptr_t) const REQUIRES_SHARED(Locks::mutator_lock_) {
+ return IsNull();
+ }
+
+ ALWAYS_INLINE bool operator!=(const ObjPtr& ptr) const REQUIRES_SHARED(Locks::mutator_lock_) {
+ return Decode() != ptr.Decode();
+ }
+
+ ALWAYS_INLINE bool operator!=(const MirrorType* ptr) const REQUIRES_SHARED(Locks::mutator_lock_) {
+ return Decode() != ptr;
+ }
+
+ ALWAYS_INLINE bool operator!=(std::nullptr_t) const REQUIRES_SHARED(Locks::mutator_lock_) {
+ return !IsNull();
+ }
+
+ private:
+ // Trim off high bits of thread local cookie.
+ ALWAYS_INLINE static uintptr_t TrimCookie(uintptr_t cookie) {
+ return cookie & kCookieMask;
+ }
+
+ ALWAYS_INLINE uintptr_t GetCookie() const {
+ return reference_ >> kCookieShift;
+ }
+
+ ALWAYS_INLINE static uintptr_t Encode(MirrorType* ptr) REQUIRES_SHARED(Locks::mutator_lock_) {
+ uintptr_t ref = reinterpret_cast<uintptr_t>(ptr);
+ if (kPoison && ref != 0) {
+ DCHECK_LE(ref, 0xFFFFFFFFU);
+ ref >>= kObjectAlignmentShift;
+ // Put cookie in high bits.
+ Thread* self = Thread::Current();
+ DCHECK(self != nullptr);
+ ref |= self->GetPoisonObjectCookie() << kCookieShift;
+ }
+ return ref;
+ }
+
+ // Decode makes sure that the object pointer is valid.
+ ALWAYS_INLINE MirrorType* Decode() const REQUIRES_SHARED(Locks::mutator_lock_) {
+ AssertValid();
+ if (kPoison) {
+ return reinterpret_cast<MirrorType*>(
+ static_cast<uintptr_t>(static_cast<uint32_t>(reference_ << kObjectAlignmentShift)));
+ } else {
+ return reinterpret_cast<MirrorType*>(reference_);
+ }
+ }
+
+ // The encoded reference and cookie.
+ uintptr_t reference_;
+};
+
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_RUNTIME_MIRROR_OBJ_PTR_H_
diff --git a/runtime/mirror/object_test.cc b/runtime/mirror/object_test.cc
index afd6115..f4ecfb5 100644
--- a/runtime/mirror/object_test.cc
+++ b/runtime/mirror/object_test.cc
@@ -35,6 +35,7 @@
#include "gc/heap.h"
#include "handle_scope-inl.h"
#include "iftable-inl.h"
+#include "obj_ptr.h"
#include "object-inl.h"
#include "object_array-inl.h"
#include "scoped_thread_state_change.h"
@@ -738,5 +739,62 @@
EXPECT_NE(hash_code, 0);
}
+TEST_F(ObjectTest, ObjectPointer) {
+ ScopedObjectAccess soa(Thread::Current());
+ jobject jclass_loader = LoadDex("XandY");
+ StackHandleScope<2> hs(soa.Self());
+ ObjPtr<mirror::Object, /*kPoison*/ true> null_ptr;
+ EXPECT_TRUE(null_ptr.IsNull());
+ EXPECT_TRUE(null_ptr.IsValid());
+ EXPECT_TRUE(null_ptr.Get() == nullptr);
+ EXPECT_TRUE(null_ptr == nullptr);
+ EXPECT_TRUE(null_ptr == null_ptr);
+ EXPECT_FALSE(null_ptr != null_ptr);
+ EXPECT_FALSE(null_ptr != nullptr);
+ null_ptr.AssertValid();
+ Handle<ClassLoader> class_loader(hs.NewHandle(soa.Decode<ClassLoader*>(jclass_loader)));
+ Handle<mirror::Class> h_X(
+ hs.NewHandle(class_linker_->FindClass(soa.Self(), "LX;", class_loader)));
+ ObjPtr<Class, /*kPoison*/ true> X(h_X.Get());
+ EXPECT_TRUE(!X.IsNull());
+ EXPECT_TRUE(X.IsValid());
+ EXPECT_TRUE(X.Get() != nullptr);
+ EXPECT_EQ(h_X.Get(), X.Get());
+ // FindClass may cause thread suspension, it should invalidate X.
+ ObjPtr<Class, /*kPoison*/ true> Y(class_linker_->FindClass(soa.Self(), "LY;", class_loader));
+ EXPECT_TRUE(!Y.IsNull());
+ EXPECT_TRUE(Y.IsValid());
+ EXPECT_TRUE(Y.Get() != nullptr);
+
+ // Should IsNull be safe to call on null ObjPtr? I'll allow it for now.
+ EXPECT_TRUE(!X.IsNull());
+ EXPECT_TRUE(!X.IsValid());
+ // Make X valid again by copying out of handle.
+ X.Assign(h_X.Get());
+ EXPECT_TRUE(!X.IsNull());
+ EXPECT_TRUE(X.IsValid());
+ EXPECT_EQ(h_X.Get(), X.Get());
+
+ // Allow thread suspension to invalidate Y.
+ soa.Self()->AllowThreadSuspension();
+ EXPECT_TRUE(!Y.IsNull());
+ EXPECT_TRUE(!Y.IsValid());
+
+ // Test unpoisoned.
+ ObjPtr<mirror::Object, /*kPoison*/ false> unpoisoned;
+ EXPECT_TRUE(unpoisoned.IsNull());
+ EXPECT_TRUE(unpoisoned.IsValid());
+ EXPECT_TRUE(unpoisoned.Get() == nullptr);
+ EXPECT_TRUE(unpoisoned == nullptr);
+ EXPECT_TRUE(unpoisoned == unpoisoned);
+ EXPECT_FALSE(unpoisoned != unpoisoned);
+ EXPECT_FALSE(unpoisoned != nullptr);
+
+ unpoisoned = h_X.Get();
+ EXPECT_FALSE(unpoisoned.IsNull());
+ EXPECT_TRUE(unpoisoned == h_X.Get());
+ EXPECT_EQ(unpoisoned.Get(), h_X.Get());
+}
+
} // namespace mirror
} // namespace art
diff --git a/runtime/thread-inl.h b/runtime/thread-inl.h
index 216d8a7..298a974 100644
--- a/runtime/thread-inl.h
+++ b/runtime/thread-inl.h
@@ -59,6 +59,7 @@
if (UNLIKELY(TestAllFlags())) {
CheckSuspend();
}
+ PoisonObjectPointers();
}
inline void Thread::CheckSuspend() {
diff --git a/runtime/thread.h b/runtime/thread.h
index 016c2bc..fb6bde6 100644
--- a/runtime/thread.h
+++ b/runtime/thread.h
@@ -471,6 +471,14 @@
}
void Notify() REQUIRES(!*wait_mutex_);
+ ALWAYS_INLINE void PoisonObjectPointers() {
+ ++poison_object_cookie_;
+ }
+
+ ALWAYS_INLINE uintptr_t GetPoisonObjectCookie() const {
+ return poison_object_cookie_;
+ }
+
private:
void NotifyLocked(Thread* self) REQUIRES(wait_mutex_);
@@ -1528,6 +1536,9 @@
// Debug disable read barrier count, only is checked for debug builds and only in the runtime.
uint8_t debug_disallow_read_barrier_ = 0;
+ // Note that it is not in the packed struct, may not be accessed for cross compilation.
+ uintptr_t poison_object_cookie_ = 0;
+
// Pending extra checkpoints if checkpoint_function_ is already used.
std::list<Closure*> checkpoint_overflow_ GUARDED_BY(Locks::thread_suspend_count_lock_);