30 #include "logging/log.hpp" 31 #include "memory/metadataFactory.hpp" 32 #include "oops/access.hpp" 33 #include "oops/compressedOops.inline.hpp" 34 #include "oops/fieldStreams.hpp" 35 #include "oops/instanceKlass.inline.hpp" 36 #include "oops/method.hpp" 37 #include "oops/oop.inline.hpp" 38 #include "oops/objArrayKlass.hpp" 39 #include "oops/valueKlass.hpp" 40 #include "oops/valueArrayKlass.hpp" 41 #include "runtime/fieldDescriptor.inline.hpp" 42 #include "runtime/handles.inline.hpp" 43 #include "runtime/safepointVerifiers.hpp" 44 #include "runtime/sharedRuntime.hpp" 45 #include "runtime/signature.hpp" 46 #include "runtime/thread.inline.hpp" 47 #include "utilities/copy.hpp" 48 49 int ValueKlass::first_field_offset() const { 50 #ifdef ASSERT 51 int first_offset = INT_MAX; 52 for (JavaFieldStream fs(this); !fs.done(); fs.next()) { 53 if (fs.offset() < first_offset) first_offset= fs.offset(); 54 } 55 #endif 56 int base_offset = instanceOopDesc::base_offset_in_bytes(); 57 // The first field of value types is aligned on a long boundary 58 base_offset = align_up(base_offset, BytesPerLong); 59 assert(base_offset == first_offset, "inconsistent offsets"); 60 return base_offset; 61 } 62 63 int ValueKlass::raw_value_byte_size() const { 64 int heapOopAlignedSize = nonstatic_field_size() << LogBytesPerHeapOop; 65 // If bigger than 64 bits or needs oop alignment, then use jlong aligned 66 // which for values should be jlong aligned, asserts in raw_field_copy otherwise 67 if (heapOopAlignedSize >= longSize || contains_oops()) { 68 return heapOopAlignedSize; 69 } 175 if (or_null) { 176 return vak->array_klass_or_null(storage_props, rank); 177 } 178 return vak->array_klass(storage_props, rank, THREAD); 179 } 180 181 Klass* ValueKlass::allocate_value_array_klass(TRAPS) { 182 if (flatten_array() && (is_atomic() || (!ValueArrayAtomicAccess))) { 183 return ValueArrayKlass::allocate_klass(ArrayStorageProperties::flattened_and_null_free, this, THREAD); 184 } 185 return ObjArrayKlass::allocate_objArray_klass(ArrayStorageProperties::null_free, 1, this, THREAD); 186 } 187 188 void ValueKlass::array_klasses_do(void f(Klass* k)) { 189 InstanceKlass::array_klasses_do(f); 190 if (get_value_array_klass() != NULL) 191 ArrayKlass::cast(get_value_array_klass())->array_klasses_do(f); 192 } 193 194 void ValueKlass::raw_field_copy(void* src, void* dst, size_t raw_byte_size) { 195 /* 196 * Try not to shear fields even if not an atomic store... 197 * 198 * First 3 cases handle value array store, otherwise works on the same basis 199 * as JVM_Clone, at this size data is aligned. The order of primitive types 200 * is largest to smallest, and it not possible for fields to stradle long 201 * copy boundaries. 202 * 203 * If MT without exclusive access, possible to observe partial value store, 204 * but not partial primitive and reference field values 205 */ 206 switch (raw_byte_size) { 207 case 1: 208 *((jbyte*) dst) = *(jbyte*)src; 209 break; 210 case 2: 211 *((jshort*) dst) = *(jshort*)src; 212 break; 213 case 4: 214 *((jint*) dst) = *(jint*) src; 215 break; 216 default: 217 assert(raw_byte_size % sizeof(jlong) == 0, "Unaligned raw_byte_size"); 218 Copy::conjoint_jlongs_atomic((jlong*)src, (jlong*)dst, raw_byte_size >> LogBytesPerLong); 219 } 220 } 221 222 /* 223 * Store the value of this klass contained with src into dst. 224 * 225 * This operation is appropriate for use from vastore, vaload and putfield (for values) 226 * 227 * GC barriers currently can lock with no safepoint check and allocate c-heap, 228 * so raw point is "safe" for now. 229 * 230 * Going forward, look to use machine generated (stub gen or bc) version for most used klass layouts 231 * 232 */ 233 void ValueKlass::value_store(void* src, void* dst, size_t raw_byte_size, bool dst_heap, bool dst_uninitialized) { 234 if (contains_oops()) { 235 if (dst_heap) { 236 // src/dst aren't oops, need offset to adjust oop map offset 237 const address dst_oop_addr = ((address) dst) - first_field_offset(); 238 239 ModRefBarrierSet* bs = barrier_set_cast<ModRefBarrierSet>(BarrierSet::barrier_set()); | 30 #include "logging/log.hpp" 31 #include "memory/metadataFactory.hpp" 32 #include "oops/access.hpp" 33 #include "oops/compressedOops.inline.hpp" 34 #include "oops/fieldStreams.hpp" 35 #include "oops/instanceKlass.inline.hpp" 36 #include "oops/method.hpp" 37 #include "oops/oop.inline.hpp" 38 #include "oops/objArrayKlass.hpp" 39 #include "oops/valueKlass.hpp" 40 #include "oops/valueArrayKlass.hpp" 41 #include "runtime/fieldDescriptor.inline.hpp" 42 #include "runtime/handles.inline.hpp" 43 #include "runtime/safepointVerifiers.hpp" 44 #include "runtime/sharedRuntime.hpp" 45 #include "runtime/signature.hpp" 46 #include "runtime/thread.inline.hpp" 47 #include "utilities/copy.hpp" 48 49 int ValueKlass::first_field_offset() const { 50 if (UseNewLayout) { 51 return get_first_field_offset(); 52 } 53 #ifdef ASSERT 54 int first_offset = INT_MAX; 55 for (JavaFieldStream fs(this); !fs.done(); fs.next()) { 56 if (fs.offset() < first_offset) first_offset= fs.offset(); 57 } 58 #endif 59 int base_offset = instanceOopDesc::base_offset_in_bytes(); 60 // The first field of value types is aligned on a long boundary 61 base_offset = align_up(base_offset, BytesPerLong); 62 assert(base_offset == first_offset, "inconsistent offsets"); 63 return base_offset; 64 } 65 66 int ValueKlass::raw_value_byte_size() const { 67 int heapOopAlignedSize = nonstatic_field_size() << LogBytesPerHeapOop; 68 // If bigger than 64 bits or needs oop alignment, then use jlong aligned 69 // which for values should be jlong aligned, asserts in raw_field_copy otherwise 70 if (heapOopAlignedSize >= longSize || contains_oops()) { 71 return heapOopAlignedSize; 72 } 178 if (or_null) { 179 return vak->array_klass_or_null(storage_props, rank); 180 } 181 return vak->array_klass(storage_props, rank, THREAD); 182 } 183 184 Klass* ValueKlass::allocate_value_array_klass(TRAPS) { 185 if (flatten_array() && (is_atomic() || (!ValueArrayAtomicAccess))) { 186 return ValueArrayKlass::allocate_klass(ArrayStorageProperties::flattened_and_null_free, this, THREAD); 187 } 188 return ObjArrayKlass::allocate_objArray_klass(ArrayStorageProperties::null_free, 1, this, THREAD); 189 } 190 191 void ValueKlass::array_klasses_do(void f(Klass* k)) { 192 InstanceKlass::array_klasses_do(f); 193 if (get_value_array_klass() != NULL) 194 ArrayKlass::cast(get_value_array_klass())->array_klasses_do(f); 195 } 196 197 void ValueKlass::raw_field_copy(void* src, void* dst, size_t raw_byte_size) { 198 if (!UseNewLayout) { 199 /* 200 * Try not to shear fields even if not an atomic store... 201 * 202 * First 3 cases handle value array store, otherwise works on the same basis 203 * as JVM_Clone, at this size data is aligned. The order of primitive types 204 * is largest to smallest, and it not possible for fields to stradle long 205 * copy boundaries. 206 * 207 * If MT without exclusive access, possible to observe partial value store, 208 * but not partial primitive and reference field values 209 */ 210 switch (raw_byte_size) { 211 case 1: 212 *((jbyte*) dst) = *(jbyte*)src; 213 break; 214 case 2: 215 *((jshort*) dst) = *(jshort*)src; 216 break; 217 case 4: 218 *((jint*) dst) = *(jint*) src; 219 break; 220 default: 221 assert(raw_byte_size % sizeof(jlong) == 0, "Unaligned raw_byte_size"); 222 Copy::conjoint_jlongs_atomic((jlong*)src, (jlong*)dst, raw_byte_size >> LogBytesPerLong); 223 } 224 } else { 225 int size = this->get_exact_size_in_bytes(); 226 int length; 227 switch (this->get_alignment()) { 228 case BytesPerLong: 229 length = size >> LogBytesPerLong; 230 if (length > 0) { 231 Copy::conjoint_jlongs_atomic((jlong*)src, (jlong*)dst, length); 232 size -= length << LogBytesPerLong; 233 src = (jlong*)src + length; 234 dst = (jlong*)dst + length; 235 } 236 // Fallthrough 237 case BytesPerInt: 238 length = size >> LogBytesPerInt; 239 if (length > 0) { 240 Copy::conjoint_jints_atomic((jint*)src, (jint*)dst, length); 241 size -= length << LogBytesPerInt; 242 src = (jint*)src + length; 243 dst = (jint*)dst + length; 244 } 245 // Fallthrough 246 case BytesPerShort: 247 length = size >> LogBytesPerShort; 248 if (length > 0) { 249 Copy::conjoint_jshorts_atomic((jshort*)src, (jshort*)dst, length); 250 size -= length << LogBytesPerShort; 251 src = (jshort*)src + length; 252 dst = (jshort*)dst +length; 253 } 254 // Fallthrough 255 case 1: 256 if (size > 0) Copy::conjoint_jbytes_atomic((jbyte*)src, (jbyte*)dst, size); 257 break; 258 default: 259 fatal("Unsupported alignment"); 260 } 261 } 262 } 263 264 /* 265 * Store the value of this klass contained with src into dst. 266 * 267 * This operation is appropriate for use from vastore, vaload and putfield (for values) 268 * 269 * GC barriers currently can lock with no safepoint check and allocate c-heap, 270 * so raw point is "safe" for now. 271 * 272 * Going forward, look to use machine generated (stub gen or bc) version for most used klass layouts 273 * 274 */ 275 void ValueKlass::value_store(void* src, void* dst, size_t raw_byte_size, bool dst_heap, bool dst_uninitialized) { 276 if (contains_oops()) { 277 if (dst_heap) { 278 // src/dst aren't oops, need offset to adjust oop map offset 279 const address dst_oop_addr = ((address) dst) - first_field_offset(); 280 281 ModRefBarrierSet* bs = barrier_set_cast<ModRefBarrierSet>(BarrierSet::barrier_set()); |