Mercurial > hg > truffle

comparison src/share/vm/oops/oop.inline.hpp @ 12226:7944aba7ba41

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 }