Mercurial > hg > graal-compiler
comparison src/share/vm/oops/oop.inline.hpp @ 12355:cefad50507d8
Merge with hs25-b53
author | Gilles Duboscq <duboscq@ssw.jku.at> |
---|---|
date | Fri, 11 Oct 2013 10:38:03 +0200 |
parents | 58fc8e2b7b6d 190899198332 |
children | d8041d695d19 |
comparison
equal
deleted
inserted
replaced
12058:ccb4f2af2319 | 12355:cefad50507d8 |
---|---|
67 inline markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) { | 67 inline markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) { |
68 return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark); | 68 return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark); |
69 } | 69 } |
70 | 70 |
71 inline Klass* oopDesc::klass() const { | 71 inline Klass* oopDesc::klass() const { |
72 if (UseCompressedKlassPointers) { | 72 if (UseCompressedClassPointers) { |
73 return Klass::decode_klass_not_null(_metadata._compressed_klass); | 73 return Klass::decode_klass_not_null(_metadata._compressed_klass); |
74 } else { | 74 } else { |
75 return _metadata._klass; | 75 return _metadata._klass; |
76 } | 76 } |
77 } | 77 } |
78 | 78 |
79 inline Klass* oopDesc::klass_or_null() const volatile { | 79 inline Klass* oopDesc::klass_or_null() const volatile { |
80 // can be NULL in CMS | 80 // can be NULL in CMS |
81 if (UseCompressedKlassPointers) { | 81 if (UseCompressedClassPointers) { |
82 return Klass::decode_klass(_metadata._compressed_klass); | 82 return Klass::decode_klass(_metadata._compressed_klass); |
83 } else { | 83 } else { |
84 return _metadata._klass; | 84 return _metadata._klass; |
85 } | 85 } |
86 } | 86 } |
87 | 87 |
88 inline int oopDesc::klass_gap_offset_in_bytes() { | 88 inline int oopDesc::klass_gap_offset_in_bytes() { |
89 assert(UseCompressedKlassPointers, "only applicable to compressed klass pointers"); | 89 assert(UseCompressedClassPointers, "only applicable to compressed klass pointers"); |
90 return oopDesc::klass_offset_in_bytes() + sizeof(narrowKlass); | 90 return oopDesc::klass_offset_in_bytes() + sizeof(narrowKlass); |
91 } | 91 } |
92 | 92 |
93 inline Klass** oopDesc::klass_addr() { | 93 inline Klass** oopDesc::klass_addr() { |
94 // Only used internally and with CMS and will not work with | 94 // Only used internally and with CMS and will not work with |
95 // UseCompressedOops | 95 // UseCompressedOops |
96 assert(!UseCompressedKlassPointers, "only supported with uncompressed klass pointers"); | 96 assert(!UseCompressedClassPointers, "only supported with uncompressed klass pointers"); |
97 return (Klass**) &_metadata._klass; | 97 return (Klass**) &_metadata._klass; |
98 } | 98 } |
99 | 99 |
100 inline narrowKlass* oopDesc::compressed_klass_addr() { | 100 inline narrowKlass* oopDesc::compressed_klass_addr() { |
101 assert(UseCompressedKlassPointers, "only called by compressed klass pointers"); | 101 assert(UseCompressedClassPointers, "only called by compressed klass pointers"); |
102 return &_metadata._compressed_klass; | 102 return &_metadata._compressed_klass; |
103 } | 103 } |
104 | 104 |
105 inline void oopDesc::set_klass(Klass* k) { | 105 inline void oopDesc::set_klass(Klass* k) { |
106 // since klasses are promoted no store check is needed | 106 // since klasses are promoted no store check is needed |
107 assert(Universe::is_bootstrapping() || k != NULL, "must be a real Klass*"); | 107 assert(Universe::is_bootstrapping() || k != NULL, "must be a real Klass*"); |
108 assert(Universe::is_bootstrapping() || k->is_klass(), "not a Klass*"); | 108 assert(Universe::is_bootstrapping() || k->is_klass(), "not a Klass*"); |
109 if (UseCompressedKlassPointers) { | 109 if (UseCompressedClassPointers) { |
110 *compressed_klass_addr() = Klass::encode_klass_not_null(k); | 110 *compressed_klass_addr() = Klass::encode_klass_not_null(k); |
111 } else { | 111 } else { |
112 *klass_addr() = k; | 112 *klass_addr() = k; |
113 } | 113 } |
114 } | 114 } |
116 inline int oopDesc::klass_gap() const { | 116 inline int oopDesc::klass_gap() const { |
117 return *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()); | 117 return *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()); |
118 } | 118 } |
119 | 119 |
120 inline void oopDesc::set_klass_gap(int v) { | 120 inline void oopDesc::set_klass_gap(int v) { |
121 if (UseCompressedKlassPointers) { | 121 if (UseCompressedClassPointers) { |
122 *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()) = v; | 122 *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()) = v; |
123 } | 123 } |
124 } | 124 } |
125 | 125 |
126 inline void oopDesc::set_klass_to_list_ptr(oop k) { | 126 inline void oopDesc::set_klass_to_list_ptr(oop k) { |
127 // This is only to be used during GC, for from-space objects, so no | 127 // This is only to be used during GC, for from-space objects, so no |
128 // barrier is needed. | 128 // barrier is needed. |
129 if (UseCompressedKlassPointers) { | 129 if (UseCompressedClassPointers) { |
130 _metadata._compressed_klass = (narrowKlass)encode_heap_oop(k); // may be null (parnew overflow handling) | 130 _metadata._compressed_klass = (narrowKlass)encode_heap_oop(k); // may be null (parnew overflow handling) |
131 } else { | 131 } else { |
132 _metadata._klass = (Klass*)(address)k; | 132 _metadata._klass = (Klass*)(address)k; |
133 } | 133 } |
134 } | 134 } |
135 | 135 |
136 inline oop oopDesc::list_ptr_from_klass() { | 136 inline oop oopDesc::list_ptr_from_klass() { |
137 // This is only to be used during GC, for from-space objects. | 137 // This is only to be used during GC, for from-space objects. |
138 if (UseCompressedKlassPointers) { | 138 if (UseCompressedClassPointers) { |
139 return decode_heap_oop((narrowOop)_metadata._compressed_klass); | 139 return decode_heap_oop((narrowOop)_metadata._compressed_klass); |
140 } else { | 140 } else { |
141 // Special case for GC | 141 // Special case for GC |
142 return (oop)(address)_metadata._klass; | 142 return (oop)(address)_metadata._klass; |
143 } | 143 } |
181 // Algorithm for encoding and decoding oops from 64 bit pointers to 32 bit | 181 // Algorithm for encoding and decoding oops from 64 bit pointers to 32 bit |
182 // offset from the heap base. Saving the check for null can save instructions | 182 // offset from the heap base. Saving the check for null can save instructions |
183 // in inner GC loops so these are separated. | 183 // in inner GC loops so these are separated. |
184 | 184 |
185 inline bool check_obj_alignment(oop obj) { | 185 inline bool check_obj_alignment(oop obj) { |
186 return (intptr_t)obj % MinObjAlignmentInBytes == 0; | 186 return cast_from_oop<intptr_t>(obj) % MinObjAlignmentInBytes == 0; |
187 } | 187 } |
188 | 188 |
189 inline narrowOop oopDesc::encode_heap_oop_not_null(oop v) { | 189 inline narrowOop oopDesc::encode_heap_oop_not_null(oop v) { |
190 assert(!is_null(v), "oop value can never be zero"); | 190 assert(!is_null(v), "oop value can never be zero"); |
191 assert(check_obj_alignment(v), "Address not aligned"); | 191 assert(check_obj_alignment(v), "Address not aligned"); |