263 }
264
265
266 // These functions are only used to exchange oop fields in instances,
267 // not headers.
268 inline oop oopDesc::atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest) {
269 if (UseCompressedOops) {
270 // encode exchange value from oop to T
271 narrowOop val = encode_heap_oop(exchange_value);
272 narrowOop old = (narrowOop)Atomic::xchg(val, (narrowOop*)dest);
273 // decode old from T to oop
274 return decode_heap_oop(old);
275 } else {
276 return (oop)Atomic::xchg_ptr(exchange_value, (oop*)dest);
277 }
278 }
279
280 // In order to put or get a field out of an instance, must first check
281 // if the field has been compressed and uncompress it.
282 inline oop oopDesc::obj_field(int offset) const {
283 return UseCompressedOops ?
284 load_decode_heap_oop(obj_field_addr<narrowOop>(offset)) :
285 load_decode_heap_oop(obj_field_addr<oop>(offset));
286 }
287
288 inline void oopDesc::obj_field_put(int offset, oop value) {
289 UseCompressedOops ? oop_store(obj_field_addr<narrowOop>(offset), value) :
290 oop_store(obj_field_addr<oop>(offset), value);
291 }
292
293 inline Metadata* oopDesc::metadata_field(int offset) const {
294 return *metadata_field_addr(offset);
295 }
296
297 inline void oopDesc::metadata_field_put(int offset, Metadata* value) {
298 *metadata_field_addr(offset) = value;
299 }
300
301 inline void oopDesc::obj_field_put_raw(int offset, oop value) {
302 UseCompressedOops ?
303 encode_store_heap_oop(obj_field_addr<narrowOop>(offset), value) :
304 encode_store_heap_oop(obj_field_addr<oop>(offset), value);
305 }
306 inline void oopDesc::obj_field_put_volatile(int offset, oop value) {
307 OrderAccess::release();
308 obj_field_put(offset, value);
309 OrderAccess::fence();
310 }
311
312 inline jbyte oopDesc::byte_field(int offset) const { return (jbyte) *byte_field_addr(offset); }
313 inline void oopDesc::byte_field_put(int offset, jbyte contents) { *byte_field_addr(offset) = (jint) contents; }
314
315 inline jboolean oopDesc::bool_field(int offset) const { return (jboolean) *bool_field_addr(offset); }
316 inline void oopDesc::bool_field_put(int offset, jboolean contents) { *bool_field_addr(offset) = (jint) contents; }
317
318 inline jchar oopDesc::char_field(int offset) const { return (jchar) *char_field_addr(offset); }
319 inline void oopDesc::char_field_put(int offset, jchar contents) { *char_field_addr(offset) = (jint) contents; }
320
321 inline jint oopDesc::int_field(int offset) const { return *int_field_addr(offset); }
322 inline void oopDesc::int_field_put(int offset, jint contents) { *int_field_addr(offset) = contents; }
323
324 inline jshort oopDesc::short_field(int offset) const { return (jshort) *short_field_addr(offset); }
325 inline void oopDesc::short_field_put(int offset, jshort contents) { *short_field_addr(offset) = (jint) contents;}
326
327 inline jlong oopDesc::long_field(int offset) const { return *long_field_addr(offset); }
328 inline void oopDesc::long_field_put(int offset, jlong contents) { *long_field_addr(offset) = contents; }
329
330 inline jfloat oopDesc::float_field(int offset) const { return *float_field_addr(offset); }
331 inline void oopDesc::float_field_put(int offset, jfloat contents) { *float_field_addr(offset) = contents; }
332
333 inline jdouble oopDesc::double_field(int offset) const { return *double_field_addr(offset); }
334 inline void oopDesc::double_field_put(int offset, jdouble contents) { *double_field_addr(offset) = contents; }
335
336 inline address oopDesc::address_field(int offset) const { return *address_field_addr(offset); }
337 inline void oopDesc::address_field_put(int offset, address contents) { *address_field_addr(offset) = contents; }
338
339 inline oop oopDesc::obj_field_acquire(int offset) const {
340 return UseCompressedOops ?
341 decode_heap_oop((narrowOop)
342 OrderAccess::load_acquire(obj_field_addr<narrowOop>(offset)))
343 : decode_heap_oop((oop)
344 OrderAccess::load_ptr_acquire(obj_field_addr<oop>(offset)));
345 }
346 inline void oopDesc::release_obj_field_put(int offset, oop value) {
347 UseCompressedOops ?
348 oop_store((volatile narrowOop*)obj_field_addr<narrowOop>(offset), value) :
349 oop_store((volatile oop*) obj_field_addr<oop>(offset), value);
350 }
351
352 inline jbyte oopDesc::byte_field_acquire(int offset) const { return OrderAccess::load_acquire(byte_field_addr(offset)); }
353 inline void oopDesc::release_byte_field_put(int offset, jbyte contents) { OrderAccess::release_store(byte_field_addr(offset), contents); }
354
355 inline jboolean oopDesc::bool_field_acquire(int offset) const { return OrderAccess::load_acquire(bool_field_addr(offset)); }
356 inline void oopDesc::release_bool_field_put(int offset, jboolean contents) { OrderAccess::release_store(bool_field_addr(offset), contents); }
357
358 inline jchar oopDesc::char_field_acquire(int offset) const { return OrderAccess::load_acquire(char_field_addr(offset)); }
359 inline void oopDesc::release_char_field_put(int offset, jchar contents) { OrderAccess::release_store(char_field_addr(offset), contents); }
360
361 inline jint oopDesc::int_field_acquire(int offset) const { return OrderAccess::load_acquire(int_field_addr(offset)); }
362 inline void oopDesc::release_int_field_put(int offset, jint contents) { OrderAccess::release_store(int_field_addr(offset), contents); }
363
364 inline jshort oopDesc::short_field_acquire(int offset) const { return (jshort)OrderAccess::load_acquire(short_field_addr(offset)); }
365 inline void oopDesc::release_short_field_put(int offset, jshort contents) { OrderAccess::release_store(short_field_addr(offset), contents); }
366
367 inline jlong oopDesc::long_field_acquire(int offset) const { return OrderAccess::load_acquire(long_field_addr(offset)); }
368 inline void oopDesc::release_long_field_put(int offset, jlong contents) { OrderAccess::release_store(long_field_addr(offset), contents); }
369
370 inline jfloat oopDesc::float_field_acquire(int offset) const { return OrderAccess::load_acquire(float_field_addr(offset)); }
371 inline void oopDesc::release_float_field_put(int offset, jfloat contents) { OrderAccess::release_store(float_field_addr(offset), contents); }
372
373 inline jdouble oopDesc::double_field_acquire(int offset) const { return OrderAccess::load_acquire(double_field_addr(offset)); }
374 inline void oopDesc::release_double_field_put(int offset, jdouble contents) { OrderAccess::release_store(double_field_addr(offset), contents); }
375
376 inline address oopDesc::address_field_acquire(int offset) const { return (address) OrderAccess::load_ptr_acquire(address_field_addr(offset)); }
377 inline void oopDesc::release_address_field_put(int offset, address contents) { OrderAccess::release_store_ptr(address_field_addr(offset), contents); }
378
379 inline int oopDesc::size_given_klass(Klass* klass) {
380 int lh = klass->layout_helper();
381 int s;
382
383 // lh is now a value computed at class initialization that may hint
384 // at the size. For instances, this is positive and equal to the
385 // size. For arrays, this is negative and provides log2 of the
386 // array element size. For other oops, it is zero and thus requires
387 // a virtual call.
388 //
389 // We go to all this trouble because the size computation is at the
390 // heart of phase 2 of mark-compaction, and called for every object,
391 // alive or dead. So the speed here is equal in importance to the
392 // speed of allocation.
393
394 if (lh > Klass::_lh_neutral_value) {
395 if (!Klass::layout_helper_needs_slow_path(lh)) {
396 s = lh >> LogHeapWordSize; // deliver size scaled by wordSize
397 } else {
|
263 }
264
265
266 // These functions are only used to exchange oop fields in instances,
267 // not headers.
268 inline oop oopDesc::atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest) {
269 if (UseCompressedOops) {
270 // encode exchange value from oop to T
271 narrowOop val = encode_heap_oop(exchange_value);
272 narrowOop old = (narrowOop)Atomic::xchg(val, (narrowOop*)dest);
273 // decode old from T to oop
274 return decode_heap_oop(old);
275 } else {
276 return (oop)Atomic::xchg_ptr(exchange_value, (oop*)dest);
277 }
278 }
279
280 // In order to put or get a field out of an instance, must first check
281 // if the field has been compressed and uncompress it.
282 inline oop oopDesc::obj_field(int offset) const {
283 oop p = bs()->read_barrier((oop) this);
284 return UseCompressedOops ?
285 load_decode_heap_oop(p->obj_field_addr<narrowOop>(offset)) :
286 load_decode_heap_oop(p->obj_field_addr<oop>(offset));
287 }
288
289 inline void oopDesc::obj_field_put(int offset, oop value) {
290 oop p = bs()->write_barrier(this);
291 value = bs()->read_barrier(value);
292 UseCompressedOops ? oop_store(p->obj_field_addr<narrowOop>(offset), value) :
293 oop_store(p->obj_field_addr<oop>(offset), value);
294 }
295
296 inline Metadata* oopDesc::metadata_field(int offset) const {
297 oop p = bs()->read_barrier((oop) this);
298 return *p->metadata_field_addr(offset);
299 }
300
301 inline void oopDesc::metadata_field_put(int offset, Metadata* value) {
302 oop p = bs()->write_barrier(this);
303 *p->metadata_field_addr(offset) = value;
304 }
305
306 inline void oopDesc::obj_field_put_raw(int offset, oop value) {
307 oop p = bs()->write_barrier(this);
308 value = bs()->read_barrier(value);
309 UseCompressedOops ?
310 encode_store_heap_oop(p->obj_field_addr<narrowOop>(offset), value) :
311 encode_store_heap_oop(p->obj_field_addr<oop>(offset), value);
312 }
313 inline void oopDesc::obj_field_put_volatile(int offset, oop value) {
314 OrderAccess::release();
315 obj_field_put(offset, value);
316 OrderAccess::fence();
317 }
318
319 inline jbyte oopDesc::byte_field(int offset) const {
320 oop p = bs()->read_barrier((oop) this);
321 return (jbyte) *p->byte_field_addr(offset);
322 }
323 inline void oopDesc::byte_field_put(int offset, jbyte contents) {
324 oop p = bs()->write_barrier(this);
325 *p->byte_field_addr(offset) = (jint) contents;
326 }
327
328 inline jboolean oopDesc::bool_field(int offset) const {
329 oop p = bs()->read_barrier((oop) this);
330 return (jboolean) *p->bool_field_addr(offset);
331 }
332 inline void oopDesc::bool_field_put(int offset, jboolean contents) {
333 oop p = bs()->write_barrier(this);
334 *p->bool_field_addr(offset) = (jint) contents;
335 }
336
337 inline jchar oopDesc::char_field(int offset) const {
338 oop p = bs()->read_barrier((oop) this);
339 return (jchar) *p->char_field_addr(offset);
340 }
341 inline void oopDesc::char_field_put(int offset, jchar contents) {
342 oop p = bs()->write_barrier(this);
343 *p->char_field_addr(offset) = (jint) contents;
344 }
345
346 inline jint oopDesc::int_field(int offset) const {
347 oop p = bs()->read_barrier((oop) this);
348 return *p->int_field_addr(offset);
349 }
350 inline void oopDesc::int_field_put(int offset, jint contents) {
351 oop p = bs()->write_barrier(this);
352 *p->int_field_addr(offset) = contents;
353 }
354
355 inline jshort oopDesc::short_field(int offset) const {
356 oop p = bs()->read_barrier((oop) this);
357 return (jshort) *p->short_field_addr(offset);
358 }
359 inline void oopDesc::short_field_put(int offset, jshort contents) {
360 oop p = bs()->write_barrier(this);
361 *p->short_field_addr(offset) = (jint) contents;
362 }
363
364 inline jlong oopDesc::long_field(int offset) const {
365 oop p = bs()->read_barrier((oop) this);
366 return *p->long_field_addr(offset);
367 }
368 inline void oopDesc::long_field_put(int offset, jlong contents) {
369 oop p = bs()->write_barrier(this);
370 *p->long_field_addr(offset) = contents;
371 }
372
373 inline jfloat oopDesc::float_field(int offset) const {
374 oop p = bs()->read_barrier((oop) this);
375 return *p->float_field_addr(offset);
376 }
377 inline void oopDesc::float_field_put(int offset, jfloat contents) {
378 oop p = bs()->write_barrier(this);
379 *p->float_field_addr(offset) = contents;
380 }
381
382 inline jdouble oopDesc::double_field(int offset) const {
383 oop p = bs()->read_barrier((oop) this);
384 return *p->double_field_addr(offset);
385 }
386 inline void oopDesc::double_field_put(int offset, jdouble contents) {
387 oop p = bs()->write_barrier(this);
388 *p->double_field_addr(offset) = contents;
389 }
390
391 inline address oopDesc::address_field(int offset) const {
392 oop p = bs()->read_barrier((oop) this);
393 return *p->address_field_addr(offset);
394 }
395 inline void oopDesc::address_field_put(int offset, address contents) {
396 oop p = bs()->write_barrier(this);
397 *p->address_field_addr(offset) = contents;
398 }
399
400 inline oop oopDesc::obj_field_acquire(int offset) const {
401 oop p = bs()->read_barrier((oop) this);
402 return UseCompressedOops ?
403 decode_heap_oop((narrowOop)
404 OrderAccess::load_acquire(p->obj_field_addr<narrowOop>(offset)))
405 : decode_heap_oop((oop)
406 OrderAccess::load_ptr_acquire(p->obj_field_addr<oop>(offset)));
407 }
408 inline void oopDesc::release_obj_field_put(int offset, oop value) {
409 oop p = bs()->write_barrier(this);
410 value = bs()->read_barrier(value);
411 UseCompressedOops ?
412 oop_store((volatile narrowOop*)p->obj_field_addr<narrowOop>(offset), value) :
413 oop_store((volatile oop*) p->obj_field_addr<oop>(offset), value);
414 }
415
416 inline jbyte oopDesc::byte_field_acquire(int offset) const {
417 oop p = bs()->read_barrier((oop) this);
418 return OrderAccess::load_acquire(p->byte_field_addr(offset));
419 }
420 inline void oopDesc::release_byte_field_put(int offset, jbyte contents) {
421 oop p = bs()->write_barrier(this);
422 OrderAccess::release_store(p->byte_field_addr(offset), contents);
423 }
424
425 inline jboolean oopDesc::bool_field_acquire(int offset) const {
426 oop p = bs()->read_barrier((oop) this);
427 return OrderAccess::load_acquire(p->bool_field_addr(offset));
428 }
429 inline void oopDesc::release_bool_field_put(int offset, jboolean contents) {
430 oop p = bs()->write_barrier(this);
431 OrderAccess::release_store(p->bool_field_addr(offset), contents);
432 }
433
434 inline jchar oopDesc::char_field_acquire(int offset) const {
435 oop p = bs()->read_barrier((oop) this);
436 return OrderAccess::load_acquire(p->char_field_addr(offset));
437 }
438 inline void oopDesc::release_char_field_put(int offset, jchar contents) {
439 oop p = bs()->write_barrier(this);
440 OrderAccess::release_store(p->char_field_addr(offset), contents);
441 }
442
443 inline jint oopDesc::int_field_acquire(int offset) const {
444 oop p = bs()->read_barrier((oop) this);
445 return OrderAccess::load_acquire(p->int_field_addr(offset));
446 }
447 inline void oopDesc::release_int_field_put(int offset, jint contents) {
448 oop p = bs()->write_barrier(this);
449 OrderAccess::release_store(p->int_field_addr(offset), contents);
450 }
451
452 inline jshort oopDesc::short_field_acquire(int offset) const {
453 oop p = bs()->read_barrier((oop) this);
454 return (jshort)OrderAccess::load_acquire(p->short_field_addr(offset));
455 }
456 inline void oopDesc::release_short_field_put(int offset, jshort contents) {
457 oop p = bs()->write_barrier(this);
458 OrderAccess::release_store(p->short_field_addr(offset), contents);
459 }
460
461 inline jlong oopDesc::long_field_acquire(int offset) const {
462 oop p = bs()->read_barrier((oop) this);
463 return OrderAccess::load_acquire(p->long_field_addr(offset));
464 }
465 inline void oopDesc::release_long_field_put(int offset, jlong contents) {
466 oop p = bs()->write_barrier(this);
467 OrderAccess::release_store(p->long_field_addr(offset), contents);
468 }
469
470 inline jfloat oopDesc::float_field_acquire(int offset) const {
471 oop p = bs()->read_barrier((oop) this);
472 return OrderAccess::load_acquire(p->float_field_addr(offset));
473 }
474 inline void oopDesc::release_float_field_put(int offset, jfloat contents) {
475 oop p = bs()->write_barrier(this);
476 OrderAccess::release_store(p->float_field_addr(offset), contents);
477 }
478
479 inline jdouble oopDesc::double_field_acquire(int offset) const {
480 oop p = bs()->read_barrier((oop) this);
481 return OrderAccess::load_acquire(p->double_field_addr(offset));
482 }
483 inline void oopDesc::release_double_field_put(int offset, jdouble contents) {
484 oop p = bs()->write_barrier(this);
485 OrderAccess::release_store(p->double_field_addr(offset), contents);
486 }
487
488 inline address oopDesc::address_field_acquire(int offset) const {
489 oop p = bs()->read_barrier((oop) this);
490 return (address) OrderAccess::load_ptr_acquire(p->address_field_addr(offset));
491 }
492 inline void oopDesc::release_address_field_put(int offset, address contents) {
493 oop p = bs()->write_barrier(this);
494 OrderAccess::release_store_ptr(p->address_field_addr(offset), contents);
495 }
496
497 inline int oopDesc::size_given_klass(Klass* klass) {
498 int lh = klass->layout_helper();
499 int s;
500
501 // lh is now a value computed at class initialization that may hint
502 // at the size. For instances, this is positive and equal to the
503 // size. For arrays, this is negative and provides log2 of the
504 // array element size. For other oops, it is zero and thus requires
505 // a virtual call.
506 //
507 // We go to all this trouble because the size computation is at the
508 // heart of phase 2 of mark-compaction, and called for every object,
509 // alive or dead. So the speed here is equal in importance to the
510 // speed of allocation.
511
512 if (lh > Klass::_lh_neutral_value) {
513 if (!Klass::layout_helper_needs_slow_path(lh)) {
514 s = lh >> LogHeapWordSize; // deliver size scaled by wordSize
515 } else {
|