object_reference.h revision 90443477f9a0061581c420775ce3b7eeae7468bc 
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
23namespace art {
24namespace mirror {
25
26class 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.
33template<bool kPoisonReferences, class MirrorType>
34class MANAGED ObjectReference {
35 public:
36  MirrorType* AsMirrorPtr() const SHARED_REQUIRES(Locks::mutator_lock_) {
37    return UnCompress();
38  }
39
40  void Assign(MirrorType* other) SHARED_REQUIRES(Locks::mutator_lock_) {
41    reference_ = Compress(other);
42  }
43
44  void Clear() {
45    reference_ = 0;
46    DCHECK(IsNull());
47  }
48
49  bool IsNull() const {
50    return reference_ == 0;
51  }
52
53  uint32_t AsVRegValue() const {
54    return reference_;
55  }
56
57 protected:
58  ObjectReference<kPoisonReferences, MirrorType>(MirrorType* mirror_ptr)
59      SHARED_REQUIRES(Locks::mutator_lock_)
60      : reference_(Compress(mirror_ptr)) {
61  }
62
63  // Compress reference to its bit representation.
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.
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.
82template<class MirrorType>
83class MANAGED HeapReference : public ObjectReference<kPoisonHeapReferences, MirrorType> {
84 public:
85  static HeapReference<MirrorType> FromMirrorPtr(MirrorType* mirror_ptr)
86      SHARED_REQUIRES(Locks::mutator_lock_) {
87    return HeapReference<MirrorType>(mirror_ptr);
88  }
89 private:
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.
95template<class MirrorType>
96class MANAGED CompressedReference : public mirror::ObjectReference<false, MirrorType> {
97 public:
98  CompressedReference<MirrorType>() SHARED_REQUIRES(Locks::mutator_lock_)
99      : mirror::ObjectReference<false, MirrorType>(nullptr) {}
100
101  static CompressedReference<MirrorType> FromMirrorPtr(MirrorType* p)
102      SHARED_REQUIRES(Locks::mutator_lock_) {
103    return CompressedReference<MirrorType>(p);
104  }
105
106 private:
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