archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 15:24:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8143014: Access PtrQueue member offsets through derived classes

Browse source 
Moved accessors to derived classes and updated callers.

Reviewed-by: tschatzl, jmasa, twisti
This commit is contained in:
Kim Barrett 2015-11-17 16:40:52 -05:00
parent bf4eef4903
commit e8c5bc2024
19 changed files with 157 additions and 88 deletions
Download patch file Download diff file Expand all files Collapse all files

10
hotspot/src/cpu/aarch64/vm/c1_Runtime1_aarch64.cpp
View file

@ -1169,12 +1169,12 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
const Register tmp = rscratch1;
Address in_progress(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_active()));
SATBMarkQueue::byte_offset_of_active()));
Address queue_index(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_index()));
SATBMarkQueue::byte_offset_of_index()));
Address buffer(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_buf()));
SATBMarkQueue::byte_offset_of_buf()));
Label done;
Label runtime;
@ -1219,9 +1219,9 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
const Register thread = rthread;
Address queue_index(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_index()));
DirtyCardQueue::byte_offset_of_index()));
Address buffer(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf()));
DirtyCardQueue::byte_offset_of_buf()));
const Register card_addr = rscratch2;
ExternalAddress cardtable((address) ct->byte_map_base);

14
hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp
View file

@ -3487,18 +3487,18 @@ void MacroAssembler::g1_write_barrier_pre(Register obj,
assert_different_registers(obj, pre_val, tmp);
Address in_progress(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_active()));
SATBMarkQueue::byte_offset_of_active()));
Address index(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_index()));
SATBMarkQueue::byte_offset_of_index()));
Address buffer(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_buf()));
SATBMarkQueue::byte_offset_of_buf()));
// Is marking active?
if (in_bytes(PtrQueue::byte_width_of_active()) == 4) {
if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
ldrw(tmp, in_progress);
} else {
assert(in_bytes(PtrQueue::byte_width_of_active()) == 1, "Assumption");
assert(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1, "Assumption");
ldrb(tmp, in_progress);
}
cbzw(tmp, done);
@ -3566,9 +3566,9 @@ void MacroAssembler::g1_write_barrier_post(Register store_addr,
assert(thread == rthread, "must be");
Address queue_index(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_index()));
DirtyCardQueue::byte_offset_of_index()));
Address buffer(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf()));
DirtyCardQueue::byte_offset_of_buf()));
BarrierSet* bs = Universe::heap()->barrier_set();
CardTableModRefBS* ct = (CardTableModRefBS*)bs;

20
hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
View file

@ -2633,11 +2633,11 @@ void MacroAssembler::g1_write_barrier_pre(Register Robj, RegisterOrConstant offs
Label runtime, filtered;
// Is marking active?
if (in_bytes(PtrQueue::byte_width_of_active()) == 4) {
lwz(Rtmp1, in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_active()), R16_thread);
if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
lwz(Rtmp1, in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_active()), R16_thread);
} else {
guarantee(in_bytes(PtrQueue::byte_width_of_active()) == 1, "Assumption");
lbz(Rtmp1, in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_active()), R16_thread);
guarantee(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1, "Assumption");
lbz(Rtmp1, in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_active()), R16_thread);
}
cmpdi(CCR0, Rtmp1, 0);
beq(CCR0, filtered);
@ -2672,13 +2672,13 @@ void MacroAssembler::g1_write_barrier_pre(Register Robj, RegisterOrConstant offs
// (The index field is typed as size_t.)
const Register Rbuffer = Rtmp1, Rindex = Rtmp2;
ld(Rindex, in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_index()), R16_thread);
ld(Rindex, in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_index()), R16_thread);
cmpdi(CCR0, Rindex, 0);
beq(CCR0, runtime); // If index == 0, goto runtime.
ld(Rbuffer, in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_buf()), R16_thread);
ld(Rbuffer, in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_buf()), R16_thread);
addi(Rindex, Rindex, -wordSize); // Decrement index.
std(Rindex, in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_index()), R16_thread);
std(Rindex, in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_index()), R16_thread);
// Record the previous value.
stdx(Rpre_val, Rbuffer, Rindex);
@ -2757,13 +2757,13 @@ void MacroAssembler::g1_write_barrier_post(Register Rstore_addr, Register Rnew_v
const Register Rqueue_index = Rtmp2,
Rqueue_buf = Rtmp3;
ld(Rqueue_index, in_bytes(JavaThread::dirty_card_queue_offset() + PtrQueue::byte_offset_of_index()), R16_thread);
ld(Rqueue_index, in_bytes(JavaThread::dirty_card_queue_offset() + DirtyCardQueue::byte_offset_of_index()), R16_thread);
cmpdi(CCR0, Rqueue_index, 0);
beq(CCR0, runtime); // index == 0 then jump to runtime
ld(Rqueue_buf, in_bytes(JavaThread::dirty_card_queue_offset() + PtrQueue::byte_offset_of_buf()), R16_thread);
ld(Rqueue_buf, in_bytes(JavaThread::dirty_card_queue_offset() + DirtyCardQueue::byte_offset_of_buf()), R16_thread);
addi(Rqueue_index, Rqueue_index, -wordSize); // decrement index
std(Rqueue_index, in_bytes(JavaThread::dirty_card_queue_offset() + PtrQueue::byte_offset_of_index()), R16_thread);
std(Rqueue_index, in_bytes(JavaThread::dirty_card_queue_offset() + DirtyCardQueue::byte_offset_of_index()), R16_thread);
stdx(Rcard_addr, Rqueue_buf, Rqueue_index); // store card
b(filtered);

8
hotspot/src/cpu/ppc/vm/stubGenerator_ppc.cpp
View file

@ -630,11 +630,11 @@ class StubGenerator: public StubCodeGenerator {
Label filtered;
// Is marking active?
if (in_bytes(PtrQueue::byte_width_of_active()) == 4) {
__ lwz(Rtmp1, in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_active()), R16_thread);
if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
__ lwz(Rtmp1, in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_active()), R16_thread);
} else {
guarantee(in_bytes(PtrQueue::byte_width_of_active()) == 1, "Assumption");
__ lbz(Rtmp1, in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_active()), R16_thread);
guarantee(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1, "Assumption");
__ lbz(Rtmp1, in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_active()), R16_thread);
}
__ cmpdi(CCR0, Rtmp1, 0);
__ beq(CCR0, filtered);

12
hotspot/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp
View file

@ -857,13 +857,13 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
bool with_frame = false; // I don't know if we can do with-frame.
int satb_q_index_byte_offset =
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_index());
SATBMarkQueue::byte_offset_of_index());
int satb_q_buf_byte_offset =
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_buf());
SATBMarkQueue::byte_offset_of_buf());
__ bind(restart);
// Load the index into the SATB buffer. PtrQueue::_index is a
// Load the index into the SATB buffer. SATBMarkQueue::_index is a
// size_t so ld_ptr is appropriate
__ ld_ptr(G2_thread, satb_q_index_byte_offset, tmp);
@ -961,14 +961,14 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
int dirty_card_q_index_byte_offset =
in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_index());
DirtyCardQueue::byte_offset_of_index());
int dirty_card_q_buf_byte_offset =
in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf());
DirtyCardQueue::byte_offset_of_buf());
__ bind(restart);
// Get the index into the update buffer. PtrQueue::_index is
// Get the index into the update buffer. DirtyCardQueue::_index is
// a size_t so ld_ptr is appropriate here.
__ ld_ptr(G2_thread, dirty_card_q_index_byte_offset, tmp3);

24
hotspot/src/cpu/sparc/vm/macroAssembler_sparc.cpp
View file

@ -3632,19 +3632,19 @@ static void generate_satb_log_enqueue(bool with_frame) {
int satb_q_index_byte_offset =
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_index());
SATBMarkQueue::byte_offset_of_index());
int satb_q_buf_byte_offset =
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_buf());
SATBMarkQueue::byte_offset_of_buf());
assert(in_bytes(PtrQueue::byte_width_of_index()) == sizeof(intptr_t) &&
in_bytes(PtrQueue::byte_width_of_buf()) == sizeof(intptr_t),
assert(in_bytes(SATBMarkQueue::byte_width_of_index()) == sizeof(intptr_t) &&
in_bytes(SATBMarkQueue::byte_width_of_buf()) == sizeof(intptr_t),
"check sizes in assembly below");
__ bind(restart);
// Load the index into the SATB buffer. PtrQueue::_index is a size_t
// Load the index into the SATB buffer. SATBMarkQueue::_index is a size_t
// so ld_ptr is appropriate.
__ ld_ptr(G2_thread, satb_q_index_byte_offset, L0);
@ -3736,17 +3736,17 @@ void MacroAssembler::g1_write_barrier_pre(Register obj,
}
// Is marking active?
if (in_bytes(PtrQueue::byte_width_of_active()) == 4) {
if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
ld(G2,
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_active()),
SATBMarkQueue::byte_offset_of_active()),
tmp);
} else {
guarantee(in_bytes(PtrQueue::byte_width_of_active()) == 1,
guarantee(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1,
"Assumption");
ldsb(G2,
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_active()),
SATBMarkQueue::byte_offset_of_active()),
tmp);
}
@ -3847,13 +3847,13 @@ static void generate_dirty_card_log_enqueue(jbyte* byte_map_base) {
int dirty_card_q_index_byte_offset =
in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_index());
DirtyCardQueue::byte_offset_of_index());
int dirty_card_q_buf_byte_offset =
in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf());
DirtyCardQueue::byte_offset_of_buf());
__ bind(restart);
// Load the index into the update buffer. PtrQueue::_index is
// Load the index into the update buffer. DirtyCardQueue::_index is
// a size_t so ld_ptr is appropriate here.
__ ld_ptr(G2_thread, dirty_card_q_index_byte_offset, L0);

8
hotspot/src/cpu/x86/vm/c1_Runtime1_x86.cpp
View file

@ -1622,9 +1622,9 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
NOT_LP64(__ get_thread(thread);)
Address queue_index(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_index()));
SATBMarkQueue::byte_offset_of_index()));
Address buffer(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_buf()));
SATBMarkQueue::byte_offset_of_buf()));
Label done;
Label runtime;
@ -1698,9 +1698,9 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
const Register thread = NOT_LP64(rax) LP64_ONLY(r15_thread);
Address queue_index(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_index()));
DirtyCardQueue::byte_offset_of_index()));
Address buffer(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf()));
DirtyCardQueue::byte_offset_of_buf()));
__ push(rax);
__ push(rcx);

14
hotspot/src/cpu/x86/vm/macroAssembler_x86.cpp
View file

@ -4248,18 +4248,18 @@ void MacroAssembler::g1_write_barrier_pre(Register obj,
}
Address in_progress(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_active()));
SATBMarkQueue::byte_offset_of_active()));
Address index(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_index()));
SATBMarkQueue::byte_offset_of_index()));
Address buffer(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_buf()));
SATBMarkQueue::byte_offset_of_buf()));
// Is marking active?
if (in_bytes(PtrQueue::byte_width_of_active()) == 4) {
if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
cmpl(in_progress, 0);
} else {
assert(in_bytes(PtrQueue::byte_width_of_active()) == 1, "Assumption");
assert(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1, "Assumption");
cmpb(in_progress, 0);
}
jcc(Assembler::equal, done);
@ -4346,9 +4346,9 @@ void MacroAssembler::g1_write_barrier_post(Register store_addr,
#endif // _LP64
Address queue_index(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_index()));
DirtyCardQueue::byte_offset_of_index()));
Address buffer(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf()));
DirtyCardQueue::byte_offset_of_buf()));
CardTableModRefBS* ct =
barrier_set_cast<CardTableModRefBS>(Universe::heap()->barrier_set());

19
hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotVMConfig.java
View file

@ -1193,9 +1193,12 @@ public class HotSpotVMConfig {
@HotSpotVMConstant(name = "frame::interpreter_frame_sender_sp_offset", archs = {"amd64"}) @Stable public int frameInterpreterFrameSenderSpOffset;
@HotSpotVMConstant(name = "frame::interpreter_frame_last_sp_offset", archs = {"amd64"}) @Stable public int frameInterpreterFrameLastSpOffset;
@HotSpotVMField(name = "PtrQueue::_active", type = "bool", get = HotSpotVMField.Type.OFFSET) @Stable public int ptrQueueActiveOffset;
@HotSpotVMField(name = "PtrQueue::_buf", type = "void**", get = HotSpotVMField.Type.OFFSET) @Stable public int ptrQueueBufferOffset;
@HotSpotVMField(name = "PtrQueue::_index", type = "size_t", get = HotSpotVMField.Type.OFFSET) @Stable public int ptrQueueIndexOffset;
@HotSpotVMConstant(name = "dirtyCardQueueBufferOffset") @Stable private int dirtyCardQueueBufferOffset;
@HotSpotVMConstant(name = "dirtyCardQueueIndexOffset") @Stable private int dirtyCardQueueIndexOffset;
@HotSpotVMConstant(name = "satbMarkQueueBufferOffset") @Stable private int satbMarkQueueBufferOffset;
@HotSpotVMConstant(name = "satbMarkQueueIndexOffset") @Stable private int satbMarkQueueIndexOffset;
@HotSpotVMConstant(name = "satbMarkQueueActiveOffset") @Stable private int satbMarkQueueActiveOffset;
@HotSpotVMField(name = "OSThread::_interrupted", type = "jint", get = HotSpotVMField.Type.OFFSET) @Stable public int osThreadInterruptedOffset;
@ -1396,23 +1399,23 @@ public class HotSpotVMConfig {
// G1 Collector Related Values.
public int g1CardQueueIndexOffset() {
return javaThreadDirtyCardQueueOffset + ptrQueueIndexOffset;
return javaThreadDirtyCardQueueOffset + dirtyCardQueueIndexOffset;
}
public int g1CardQueueBufferOffset() {
return javaThreadDirtyCardQueueOffset + ptrQueueBufferOffset;
return javaThreadDirtyCardQueueOffset + dirtyCardQueueBufferOffset;
}
public int g1SATBQueueMarkingOffset() {
return javaThreadSatbMarkQueueOffset + ptrQueueActiveOffset;
return javaThreadSatbMarkQueueOffset + satbMarkQueueActiveOffset;
}
public int g1SATBQueueIndexOffset() {
return javaThreadSatbMarkQueueOffset + ptrQueueIndexOffset;
return javaThreadSatbMarkQueueOffset + satbMarkQueueIndexOffset;
}
public int g1SATBQueueBufferOffset() {
return javaThreadSatbMarkQueueOffset + ptrQueueBufferOffset;
return javaThreadSatbMarkQueueOffset + satbMarkQueueBufferOffset;
}
@HotSpotVMField(name = "java_lang_Class::_klass_offset", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int klassOffset;

6
hotspot/src/share/vm/c1/c1_LIRGenerator.cpp
View file

@ -1464,10 +1464,10 @@ void LIRGenerator::G1SATBCardTableModRef_pre_barrier(LIR_Opr addr_opr, LIR_Opr p
bool do_load, bool patch, CodeEmitInfo* info) {
// First we test whether marking is in progress.
BasicType flag_type;
if (in_bytes(PtrQueue::byte_width_of_active()) == 4) {
if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
flag_type = T_INT;
} else {
guarantee(in_bytes(PtrQueue::byte_width_of_active()) == 1,
guarantee(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1,
"Assumption");
// Use unsigned type T_BOOLEAN here rather than signed T_BYTE since some platforms, eg. ARM,
// need to use unsigned instructions to use the large offset to load the satb_mark_queue.
@ -1477,7 +1477,7 @@ void LIRGenerator::G1SATBCardTableModRef_pre_barrier(LIR_Opr addr_opr, LIR_Opr p
LIR_Address* mark_active_flag_addr =
new LIR_Address(thrd,
in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_active()),
SATBMarkQueue::byte_offset_of_active()),
flag_type);
// Read the marking-in-progress flag.
LIR_Opr flag_val = new_register(T_INT);

12
hotspot/src/share/vm/gc/g1/dirtyCardQueue.hpp
View file

@ -72,6 +72,18 @@ public:
void **get_buf() { return _buf;}
size_t get_index() { return _index;}
void reinitialize() { _buf = 0; _sz = 0; _index = 0;}
// Compiler support.
static ByteSize byte_offset_of_index() {
return PtrQueue::byte_offset_of_index<DirtyCardQueue>();
}
using PtrQueue::byte_width_of_index;
static ByteSize byte_offset_of_buf() {
return PtrQueue::byte_offset_of_buf<DirtyCardQueue>();
}
using PtrQueue::byte_width_of_buf;
};

14
hotspot/src/share/vm/gc/g1/ptrQueue.hpp
View file

@ -140,19 +140,27 @@ public:
}
// To support compiler.
protected:
template<typename Derived>
static ByteSize byte_offset_of_index() {
return byte_offset_of(PtrQueue, _index);
return byte_offset_of(Derived, _index);
}
static ByteSize byte_width_of_index() { return in_ByteSize(sizeof(size_t)); }
template<typename Derived>
static ByteSize byte_offset_of_buf() {
return byte_offset_of(PtrQueue, _buf);
return byte_offset_of(Derived, _buf);
}
static ByteSize byte_width_of_buf() { return in_ByteSize(sizeof(void*)); }
template<typename Derived>
static ByteSize byte_offset_of_active() {
return byte_offset_of(PtrQueue, _active);
return byte_offset_of(Derived, _active);
}
static ByteSize byte_width_of_active() { return in_ByteSize(sizeof(bool)); }
};

17
hotspot/src/share/vm/gc/g1/satbMarkQueue.hpp
View file

@ -68,6 +68,23 @@ public:
void print(const char* name);
static void print(const char* name, void** buf, size_t index, size_t sz);
#endif // PRODUCT
// Compiler support.
static ByteSize byte_offset_of_index() {
return PtrQueue::byte_offset_of_index<SATBMarkQueue>();
}
using PtrQueue::byte_width_of_index;
static ByteSize byte_offset_of_buf() {
return PtrQueue::byte_offset_of_buf<SATBMarkQueue>();
}
using PtrQueue::byte_width_of_buf;
static ByteSize byte_offset_of_active() {
return PtrQueue::byte_offset_of_active<SATBMarkQueue>();
}
using PtrQueue::byte_width_of_active;
};
class SATBMarkQueueSet: public PtrQueueSet {

31
hotspot/src/share/vm/gc/g1/vmStructs_g1.hpp
View file

@ -28,6 +28,7 @@
#include "gc/g1/g1CollectedHeap.hpp"
#include "gc/g1/heapRegion.hpp"
#include "gc/g1/heapRegionManager.hpp"
#include "utilities/macros.hpp"
#define VM_STRUCTS_G1(nonstatic_field, static_field) \
\
@ -62,6 +63,34 @@
\
nonstatic_field(HeapRegionSetCount, _length, uint) \
nonstatic_field(HeapRegionSetCount, _capacity, size_t) \
\
nonstatic_field(PtrQueue, _active, bool) \
nonstatic_field(PtrQueue, _buf, void**) \
nonstatic_field(PtrQueue, _index, size_t) \
#define VM_INT_CONSTANTS_G1(declare_constant, declare_constant_with_value) \
\
JVMCI_ONLY( \
declare_constant_with_value( \
"dirtyCardQueueBufferOffset", \
in_bytes(DirtyCardQueue::byte_offset_of_buf())) \
declare_constant_with_value( \
"dirtyCardQueueIndexOffset", \
in_bytes(DirtyCardQueue::byte_offset_of_index())) \
) /* JVMCI_ONLY */ \
\
JVMCI_ONLY( \
declare_constant_with_value( \
"satbMarkQueueBufferOffset", \
in_bytes(SATBMarkQueue::byte_offset_of_buf())) \
declare_constant_with_value( \
"satbMarkQueueIndexOffset", \
in_bytes(SATBMarkQueue::byte_offset_of_index())) \
declare_constant_with_value( \
"satbMarkQueueActiveOffset", \
in_bytes(SATBMarkQueue::byte_offset_of_active())) \
) /* JVMCI_ONLY */ \
#define VM_TYPES_G1(declare_type, declare_toplevel_type) \
@ -76,10 +105,10 @@
declare_toplevel_type(HeapRegionSetBase) \
declare_toplevel_type(HeapRegionSetCount) \
declare_toplevel_type(G1MonitoringSupport) \
declare_toplevel_type(PtrQueue) \
\
declare_toplevel_type(G1CollectedHeap*) \
declare_toplevel_type(HeapRegion*) \
declare_toplevel_type(G1MonitoringSupport*) \
#endif // SHARE_VM_GC_G1_VMSTRUCTS_G1_HPP

2
hotspot/src/share/vm/opto/compile.cpp
View file

@ -3549,7 +3549,7 @@ void Compile::verify_graph_edges(bool no_dead_code) {
void Compile::verify_barriers() {
if (UseG1GC) {
// Verify G1 pre-barriers
const int marking_offset = in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_active());
const int marking_offset = in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_active());
ResourceArea *area = Thread::current()->resource_area();
Unique_Node_List visited(area);

4
hotspot/src/share/vm/opto/escape.cpp
View file

@ -539,11 +539,11 @@ void ConnectionGraph::add_node_to_connection_graph(Node *n, Unique_Node_List *de
if (tls->Opcode() == Op_ThreadLocal) {
int offs = (int)igvn->find_intptr_t_con(adr->in(AddPNode::Offset), Type::OffsetBot);
if (offs == in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_buf())) {
SATBMarkQueue::byte_offset_of_buf())) {
break; // G1 pre barrier previous oop value store.
}
if (offs == in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf())) {
DirtyCardQueue::byte_offset_of_buf())) {
break; // G1 post barrier card address store.
}
}

16
hotspot/src/share/vm/opto/graphKit.cpp
View file

@ -3986,16 +3986,16 @@ void GraphKit::g1_write_barrier_pre(bool do_load,
float likely = PROB_LIKELY(0.999);
float unlikely = PROB_UNLIKELY(0.999);
BasicType active_type = in_bytes(PtrQueue::byte_width_of_active()) == 4 ? T_INT : T_BYTE;
assert(in_bytes(PtrQueue::byte_width_of_active()) == 4 || in_bytes(PtrQueue::byte_width_of_active()) == 1, "flag width");
BasicType active_type = in_bytes(SATBMarkQueue::byte_width_of_active()) == 4 ? T_INT : T_BYTE;
assert(in_bytes(SATBMarkQueue::byte_width_of_active()) == 4 || in_bytes(SATBMarkQueue::byte_width_of_active()) == 1, "flag width");
// Offsets into the thread
const int marking_offset = in_bytes(JavaThread::satb_mark_queue_offset() + // 648
PtrQueue::byte_offset_of_active());
SATBMarkQueue::byte_offset_of_active());
const int index_offset = in_bytes(JavaThread::satb_mark_queue_offset() + // 656
PtrQueue::byte_offset_of_index());
SATBMarkQueue::byte_offset_of_index());
const int buffer_offset = in_bytes(JavaThread::satb_mark_queue_offset() + // 652
PtrQueue::byte_offset_of_buf());
SATBMarkQueue::byte_offset_of_buf());
// Now the actual pointers into the thread
Node* marking_adr = __ AddP(no_base, tls, __ ConX(marking_offset));
@ -4008,7 +4008,7 @@ void GraphKit::g1_write_barrier_pre(bool do_load,
// if (!marking)
__ if_then(marking, BoolTest::ne, zero, unlikely); {
BasicType index_bt = TypeX_X->basic_type();
assert(sizeof(size_t) == type2aelembytes(index_bt), "Loading G1 PtrQueue::_index with wrong size.");
assert(sizeof(size_t) == type2aelembytes(index_bt), "Loading G1 SATBMarkQueue::_index with wrong size.");
Node* index = __ load(__ ctrl(), index_adr, TypeX_X, index_bt, Compile::AliasIdxRaw);
if (do_load) {
@ -4196,9 +4196,9 @@ void GraphKit::g1_write_barrier_post(Node* oop_store,
// Offsets into the thread
const int index_offset = in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_index());
DirtyCardQueue::byte_offset_of_index());
const int buffer_offset = in_bytes(JavaThread::dirty_card_queue_offset() +
PtrQueue::byte_offset_of_buf());
DirtyCardQueue::byte_offset_of_buf());
// Pointers into the thread

2
hotspot/src/share/vm/opto/macro.cpp
View file

@ -290,7 +290,7 @@ void PhaseMacroExpand::eliminate_card_mark(Node* p2x) {
cmpx->in(1)->is_Load()) {
Node* adr = cmpx->in(1)->as_Load()->in(MemNode::Address);
const int marking_offset = in_bytes(JavaThread::satb_mark_queue_offset() +
PtrQueue::byte_offset_of_active());
SATBMarkQueue::byte_offset_of_active());
if (adr->is_AddP() && adr->in(AddPNode::Base) == top() &&
adr->in(AddPNode::Address)->Opcode() == Op_ThreadLocal &&
adr->in(AddPNode::Offset) == MakeConX(marking_offset)) {

12
hotspot/src/share/vm/runtime/vmStructs.cpp
View file

@ -1378,10 +1378,6 @@ typedef CompactHashtable<Symbol*, char> SymbolCompactHashTable;
nonstatic_field(vframeArrayElement, _bci, int) \
nonstatic_field(vframeArrayElement, _method, Method*) \
\
nonstatic_field(PtrQueue, _active, bool) \
nonstatic_field(PtrQueue, _buf, void**) \
nonstatic_field(PtrQueue, _index, size_t) \
\
nonstatic_field(AccessFlags, _flags, jint) \
nonstatic_field(elapsedTimer, _counter, jlong) \
nonstatic_field(elapsedTimer, _active, bool) \
@ -2273,8 +2269,6 @@ typedef CompactHashtable<Symbol*, char> SymbolCompactHashTable;
/* Miscellaneous types */ \
/***************/ \
\
declare_toplevel_type(PtrQueue) \
\
/* freelist */ \
declare_toplevel_type(FreeChunk*) \
declare_toplevel_type(AdaptiveFreeList<FreeChunk>*) \
@ -3066,6 +3060,9 @@ typedef CompactHashtable<Symbol*, char> SymbolCompactHashTable;
#define GENERATE_VM_INT_CONSTANT_ENTRY(name) \
{ QUOTE(name), (int32_t) name },
#define GENERATE_VM_INT_CONSTANT_WITH_VALUE_ENTRY(name, value) \
{ (name), (int32_t)(value) },
#define GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) \
{ name, (int32_t) value },
@ -3296,6 +3293,9 @@ VMIntConstantEntry VMStructs::localHotSpotVMIntConstants[] = {
VM_INT_CONSTANTS_CMS(GENERATE_VM_INT_CONSTANT_ENTRY)
VM_INT_CONSTANTS_PARNEW(GENERATE_VM_INT_CONSTANT_ENTRY)
VM_INT_CONSTANTS_G1(GENERATE_VM_INT_CONSTANT_ENTRY,
GENERATE_VM_INT_CONSTANT_WITH_VALUE_ENTRY)
#endif // INCLUDE_ALL_GCS
#if INCLUDE_TRACE