Mercurial > hg > truffle
comparison src/share/vm/oops/oop.inline.hpp @ 12226:7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
Reviewed-by: coleenp, mgerdin, hseigel
author | ehelin |
---|---|
date | Mon, 12 Aug 2013 17:37:02 +0200 |
parents | 740e263c80c6 |
children | 190899198332 |
comparison
equal
deleted
inserted
replaced
12186:313b724f8911 | 12226:7944aba7ba41 |
---|---|
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 } |