1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef ART_RUNTIME_MIRROR_OBJECT_REFERENCE_H_
18 #define ART_RUNTIME_MIRROR_OBJECT_REFERENCE_H_
19 
20 #include "base/mutex.h"  // For Locks::mutator_lock_.
21 #include "globals.h"
22 
23 namespace art {
24 namespace mirror {
25 
26 class Object;
27 
28 // Classes shared with the managed side of the world need to be packed so that they don't have
29 // extra platform specific padding.
30 #define MANAGED PACKED(4)
31 
32 // Value type representing a reference to a mirror::Object of type MirrorType.
33 template<bool kPoisonReferences, class MirrorType>
34 class MANAGED ObjectReference {
35  public:
AsMirrorPtr()36   MirrorType* AsMirrorPtr() const SHARED_REQUIRES(Locks::mutator_lock_) {
37     return UnCompress();
38   }
39 
Assign(MirrorType * other)40   void Assign(MirrorType* other) SHARED_REQUIRES(Locks::mutator_lock_) {
41     reference_ = Compress(other);
42   }
43 
Clear()44   void Clear() {
45     reference_ = 0;
46     DCHECK(IsNull());
47   }
48 
IsNull()49   bool IsNull() const {
50     return reference_ == 0;
51   }
52 
AsVRegValue()53   uint32_t AsVRegValue() const {
54     return reference_;
55   }
56 
57  protected:
58   ObjectReference<kPoisonReferences, MirrorType>(MirrorType* mirror_ptr)
SHARED_REQUIRES(Locks::mutator_lock_)59       SHARED_REQUIRES(Locks::mutator_lock_)
60       : reference_(Compress(mirror_ptr)) {
61   }
62 
63   // Compress reference to its bit representation.
Compress(MirrorType * mirror_ptr)64   static uint32_t Compress(MirrorType* mirror_ptr) SHARED_REQUIRES(Locks::mutator_lock_) {
65     uintptr_t as_bits = reinterpret_cast<uintptr_t>(mirror_ptr);
66     return static_cast<uint32_t>(kPoisonReferences ? -as_bits : as_bits);
67   }
68 
69   // Uncompress an encoded reference from its bit representation.
UnCompress()70   MirrorType* UnCompress() const SHARED_REQUIRES(Locks::mutator_lock_) {
71     uintptr_t as_bits = kPoisonReferences ? -reference_ : reference_;
72     return reinterpret_cast<MirrorType*>(as_bits);
73   }
74 
75   friend class Object;
76 
77   // The encoded reference to a mirror::Object.
78   uint32_t reference_;
79 };
80 
81 // References between objects within the managed heap.
82 template<class MirrorType>
83 class MANAGED HeapReference : public ObjectReference<kPoisonHeapReferences, MirrorType> {
84  public:
FromMirrorPtr(MirrorType * mirror_ptr)85   static HeapReference<MirrorType> FromMirrorPtr(MirrorType* mirror_ptr)
86       SHARED_REQUIRES(Locks::mutator_lock_) {
87     return HeapReference<MirrorType>(mirror_ptr);
88   }
89  private:
SHARED_REQUIRES(Locks::mutator_lock_)90   HeapReference<MirrorType>(MirrorType* mirror_ptr) SHARED_REQUIRES(Locks::mutator_lock_)
91       : ObjectReference<kPoisonHeapReferences, MirrorType>(mirror_ptr) {}
92 };
93 
94 // Standard compressed reference used in the runtime. Used for StackReference and GC roots.
95 template<class MirrorType>
96 class MANAGED CompressedReference : public mirror::ObjectReference<false, MirrorType> {
97  public:
SHARED_REQUIRES(Locks::mutator_lock_)98   CompressedReference<MirrorType>() SHARED_REQUIRES(Locks::mutator_lock_)
99       : mirror::ObjectReference<false, MirrorType>(nullptr) {}
100 
FromMirrorPtr(MirrorType * p)101   static CompressedReference<MirrorType> FromMirrorPtr(MirrorType* p)
102       SHARED_REQUIRES(Locks::mutator_lock_) {
103     return CompressedReference<MirrorType>(p);
104   }
105 
106  private:
SHARED_REQUIRES(Locks::mutator_lock_)107   CompressedReference<MirrorType>(MirrorType* p) SHARED_REQUIRES(Locks::mutator_lock_)
108       : mirror::ObjectReference<false, MirrorType>(p) {}
109 };
110 
111 }  // namespace mirror
112 }  // namespace art
113 
114 #endif  // ART_RUNTIME_MIRROR_OBJECT_REFERENCE_H_
115