Skip to content

Commit 7510128

Browse files
pronpron
committedMay 19, 2021
Fortify javaVFrames wrt chunks
·
JEP-429-branchpoint
1 parent f1416eb commit 7510128

File tree

4 files changed

+55
-31
lines changed

4 files changed

+55
-31
lines changed
 

‎src/hotspot/share/runtime/frame.cpp

+4-3
Original file line numberDiff line numberDiff line change
@@ -105,7 +105,7 @@ RegisterMap::RegisterMap(const RegisterMap* map) {
105105
DEBUG_ONLY(_skip_missing = map->_skip_missing;)
106106

107107
// only the original RegisterMap's handle lives long enough for StackWalker; this is bound to cause trouble with nested continuations.
108-
_chunk = map->_chunk; // !map->_cont.is_null() && map->_cont() != NULL ? Handle(Thread::current(), map->_cont()) : Handle();
108+
_chunk = map->_chunk; // stackChunkHandle(Thread::current(), map->_chunk(), map->_chunk.not_null()); //
109109

110110
pd_initialize_from(map);
111111
if (update_map()) {
@@ -131,9 +131,10 @@ oop RegisterMap::cont() const {
131131
}
132132

133133
void RegisterMap::set_stack_chunk(stackChunkOop chunk) {
134-
assert (_walk_cont, "");
134+
assert (chunk == NULL || _walk_cont, "");
135135
assert (chunk == NULL || chunk->is_stackChunk(), "");
136-
assert (_chunk.not_null(), "");
136+
assert (chunk == NULL || _chunk.not_null(), "");
137+
if (_chunk.is_null()) return;
137138
log_trace(jvmcont)("set_stack_chunk: " INTPTR_FORMAT " this: " INTPTR_FORMAT, p2i((oopDesc*)chunk), p2i(this));
138139
*(_chunk.raw_value()) = chunk; // reuse handle. see comment above in the constructor
139140
}

‎src/hotspot/share/runtime/vframe.cpp

+34-24
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
*
2323
*/
2424

25+
#include "oops/stackChunkOop.hpp"
2526
#include "precompiled.hpp"
2627
#include "classfile/javaClasses.inline.hpp"
2728
#include "classfile/javaThreadStatus.hpp"
@@ -54,15 +55,17 @@
5455
#include "runtime/vframe_hp.hpp"
5556

5657
vframe::vframe(const frame* fr, const RegisterMap* reg_map, JavaThread* thread)
57-
: _reg_map(reg_map), _thread(thread) {
58+
: _reg_map(reg_map), _thread(thread),
59+
_chunk(Thread::current(), reg_map->stack_chunk()(), reg_map->stack_chunk().not_null()) {
5860
assert(fr != NULL, "must have frame");
5961
_fr = *fr;
6062
}
6163

6264
vframe::vframe(const frame* fr, JavaThread* thread)
63-
: _reg_map(thread), _thread(thread) {
65+
: _reg_map(thread), _thread(thread), _chunk() {
6466
assert(fr != NULL, "must have frame");
6567
_fr = *fr;
68+
assert (!_reg_map.in_cont(), "");
6669
}
6770

6871
vframe* vframe::new_vframe(StackFrameStream& fst, JavaThread* thread) {
@@ -134,6 +137,12 @@ javaVFrame* vframe::java_sender() const {
134137
return NULL;
135138
}
136139

140+
void vframe::restore_register_map() const {
141+
if (_reg_map.stack_chunk()() != stack_chunk()) {
142+
const_cast<vframe*>(this)->_reg_map.set_stack_chunk(stack_chunk());
143+
}
144+
}
145+
137146
// ------------- javaVFrame --------------
138147

139148
GrowableArray<MonitorInfo*>* javaVFrame::locked_monitors() {
@@ -283,24 +292,24 @@ void javaVFrame::print_lock_info_on(outputStream* st, int frame_count) {
283292
// ------------- interpretedVFrame --------------
284293

285294
u_char* interpretedVFrame::bcp() const {
286-
return (!register_map()->in_cont()) ? fr().interpreter_frame_bcp() : register_map()->stack_chunk()->interpreter_frame_bcp(fr());
295+
return stack_chunk() == NULL ? fr().interpreter_frame_bcp() : stack_chunk()->interpreter_frame_bcp(fr());
287296
}
288297

289298
void interpretedVFrame::set_bcp(u_char* bcp) {
290-
assert (!register_map()->in_cont(), ""); // unsupported for now because seems to be unused
299+
assert (stack_chunk() == NULL, ""); // unsupported for now because seems to be unused
291300
fr().interpreter_frame_set_bcp(bcp);
292301
}
293302

294303
intptr_t* interpretedVFrame::locals_addr_at(int offset) const {
295-
assert (!register_map()->in_cont(), ""); // unsupported for now because seems to be unused
304+
assert (stack_chunk() == NULL, ""); // unsupported for now because seems to be unused
296305
assert(fr().is_interpreted_frame(), "frame should be an interpreted frame");
297306
return fr().interpreter_frame_local_at(offset);
298307
}
299308

300309

301310
GrowableArray<MonitorInfo*>* interpretedVFrame::monitors() const {
302311
GrowableArray<MonitorInfo*>* result = new GrowableArray<MonitorInfo*>(5);
303-
if (!register_map()->in_cont()) { // no monitors in continuations
312+
if (stack_chunk() == NULL) { // no monitors in continuations
304313
for (BasicObjectLock* current = (fr().previous_monitor_in_interpreter_frame(fr().interpreter_frame_monitor_begin()));
305314
current >= fr().interpreter_frame_monitor_end();
306315
current = fr().previous_monitor_in_interpreter_frame(current)) {
@@ -315,13 +324,14 @@ int interpretedVFrame::bci() const {
315324
}
316325

317326
Method* interpretedVFrame::method() const {
318-
return (!register_map()->in_cont()) ? fr().interpreter_frame_method() : register_map()->stack_chunk()->interpreter_frame_method(fr());
327+
// assert ((stack_chunk() != NULL) == register_map()->in_cont(), "_in_cont: %d register_map()->in_cont(): %d", stack_chunk() != NULL, register_map()->in_cont());
328+
return stack_chunk() == NULL ? fr().interpreter_frame_method() : stack_chunk()->interpreter_frame_method(fr());
319329
}
320330

321-
static StackValue* create_stack_value_from_oop_map(const RegisterMap* reg_map,
322-
const InterpreterOopMap& oop_mask,
331+
static StackValue* create_stack_value_from_oop_map(const InterpreterOopMap& oop_mask,
323332
int index,
324-
const intptr_t* const addr) {
333+
const intptr_t* const addr,
334+
stackChunkOop chunk) {
325335

326336
assert(index >= 0 &&
327337
index < oop_mask.number_of_entries(), "invariant");
@@ -330,8 +340,8 @@ static StackValue* create_stack_value_from_oop_map(const RegisterMap* reg_map,
330340
if (oop_mask.is_oop(index)) {
331341
oop obj = NULL;
332342
if (addr != NULL) {
333-
if (reg_map->in_cont()) {
334-
obj = (reg_map->stack_chunk()->has_bitmap() && UseCompressedOops) ? (oop)HeapAccess<>::oop_load((narrowOop*)addr) : HeapAccess<>::oop_load((oop*)addr);
343+
if (chunk != NULL) {
344+
obj = (chunk->has_bitmap() && UseCompressedOops) ? (oop)HeapAccess<>::oop_load((narrowOop*)addr) : HeapAccess<>::oop_load((oop*)addr);
335345
} else {
336346
obj = *(oop*)addr;
337347
}
@@ -361,21 +371,21 @@ static void stack_locals(StackValueCollection* result,
361371
int length,
362372
const InterpreterOopMap& oop_mask,
363373
const frame& fr,
364-
const RegisterMap* reg_map) {
374+
const stackChunkOop chunk) {
365375

366376
assert(result != NULL, "invariant");
367377

368378
for (int i = 0; i < length; ++i) {
369379
const intptr_t* addr;
370-
if (!reg_map->in_cont()) {
380+
if (chunk == NULL) {
371381
addr = fr.interpreter_frame_local_at(i);
372382
assert(addr >= fr.sp(), "must be inside the frame");
373383
} else {
374-
addr = reg_map->stack_chunk()->interpreter_frame_local_at(fr, i);
384+
addr = chunk->interpreter_frame_local_at(fr, i);
375385
}
376386
assert(addr != NULL, "invariant");
377387

378-
StackValue* const sv = create_stack_value_from_oop_map(reg_map, oop_mask, i, addr);
388+
StackValue* const sv = create_stack_value_from_oop_map(oop_mask, i, addr, chunk);
379389
assert(sv != NULL, "sanity check");
380390

381391
result->add(sv);
@@ -387,27 +397,27 @@ static void stack_expressions(StackValueCollection* result,
387397
int max_locals,
388398
const InterpreterOopMap& oop_mask,
389399
const frame& fr,
390-
const RegisterMap* reg_map) {
400+
const stackChunkOop chunk) {
391401

392402
assert(result != NULL, "invariant");
393403

394404
for (int i = 0; i < length; ++i) {
395405
const intptr_t* addr;
396-
if (!reg_map->in_cont()) {
406+
if (chunk == NULL) {
397407
addr = fr.interpreter_frame_expression_stack_at(i);
398408
assert(addr != NULL, "invariant");
399409
if (!is_in_expression_stack(fr, addr)) {
400410
// Need to ensure no bogus escapes.
401411
addr = NULL;
402412
}
403413
} else {
404-
addr = reg_map->stack_chunk()->interpreter_frame_expression_stack_at(fr, i);
414+
addr = chunk->interpreter_frame_expression_stack_at(fr, i);
405415
}
406416

407-
StackValue* const sv = create_stack_value_from_oop_map(reg_map,
408-
oop_mask,
417+
StackValue* const sv = create_stack_value_from_oop_map(oop_mask,
409418
i + max_locals,
410-
addr);
419+
addr,
420+
chunk);
411421
assert(sv != NULL, "sanity check");
412422

413423
result->add(sv);
@@ -456,9 +466,9 @@ StackValueCollection* interpretedVFrame::stack_data(bool expressions) const {
456466
}
457467

458468
if (expressions) {
459-
stack_expressions(result, length, max_locals, oop_mask, fr(), register_map());
469+
stack_expressions(result, length, max_locals, oop_mask, fr(), stack_chunk());
460470
} else {
461-
stack_locals(result, length, oop_mask, fr(), register_map());
471+
stack_locals(result, length, oop_mask, fr(), stack_chunk());
462472
}
463473

464474
assert(length == result->size(), "invariant");

‎src/hotspot/share/runtime/vframe.hpp

+7-1
Original file line numberDiff line numberDiff line change
@@ -59,9 +59,11 @@ class vframe: public ResourceObj {
5959
frame _fr; // Raw frame behind the virtual frame.
6060
RegisterMap _reg_map; // Register map for the raw frame (used to handle callee-saved registers).
6161
JavaThread* _thread; // The thread owning the raw frame.
62+
stackChunkHandle _chunk;
6263

6364
vframe(const frame* fr, const RegisterMap* reg_map, JavaThread* thread);
6465
vframe(const frame* fr, JavaThread* thread);
66+
6567
public:
6668
// Factory methods for creating vframes
6769
static vframe* new_vframe(const frame* f, const RegisterMap *reg_map, JavaThread* thread);
@@ -79,14 +81,18 @@ class vframe: public ResourceObj {
7981
frame* frame_pointer() { return &_fr; }
8082
const RegisterMap* register_map() const { return &_reg_map; }
8183
JavaThread* thread() const { return _thread; }
82-
oop continuation() const { return _reg_map.cont(); }
84+
stackChunkOop stack_chunk() const { return _chunk(); /*_reg_map.stack_chunk();*/ }
85+
oop continuation() const { return stack_chunk() != NULL ? stack_chunk()->cont() : (oop)NULL; }
8386

8487
// Returns the sender vframe
8588
virtual vframe* sender() const;
8689

8790
// Returns the next javaVFrame on the stack (skipping all other kinds of frame)
8891
javaVFrame *java_sender() const;
8992

93+
// Call when resuming a walk (calling [java_]sender) on a frame we'e already walked past
94+
void restore_register_map() const;
95+
9096
// Answers if the this is the top vframe in the frame, i.e., if the sender vframe
9197
// is in the caller frame
9298
virtual bool is_top() const { return true; }

‎src/hotspot/share/runtime/vframe_hp.cpp

+10-3
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,7 @@
3939
#include "runtime/frame.inline.hpp"
4040
#include "runtime/handles.inline.hpp"
4141
#include "runtime/monitorChunk.hpp"
42+
#include "runtime/registerMap.hpp"
4243
#include "runtime/signature.hpp"
4344
#include "runtime/stubRoutines.hpp"
4445
#include "runtime/vframeArray.hpp"
@@ -66,7 +67,7 @@ StackValueCollection* compiledVFrame::locals() const {
6667

6768
// Replace the original values with any stores that have been
6869
// performed through compiledVFrame::update_locals.
69-
if (register_map()->cont() == NULL) { // LOOM TODO
70+
if (!register_map()->in_cont()) { // LOOM TODO
7071
GrowableArray<jvmtiDeferredLocalVariableSet*>* list = JvmtiDeferredUpdates::deferred_locals(thread());
7172
if (list != NULL ) {
7273
// In real life this never happens or is typically a single element search
@@ -197,7 +198,7 @@ StackValueCollection* compiledVFrame::expressions() const {
197198
result->add(create_stack_value(scv_list->at(i)));
198199
}
199200

200-
if (register_map()->cont() == NULL) { // LOOM TODO
201+
if (!register_map()->in_cont()) { // LOOM TODO
201202
// Replace the original values with any stores that have been
202203
// performed through compiledVFrame::update_stack.
203204
GrowableArray<jvmtiDeferredLocalVariableSet*>* list = JvmtiDeferredUpdates::deferred_locals(thread());
@@ -221,7 +222,13 @@ StackValueCollection* compiledVFrame::expressions() const {
221222
// rematerialization and relocking of non-escaping objects.
222223

223224
StackValue *compiledVFrame::create_stack_value(ScopeValue *sv) const {
224-
return StackValue::create_stack_value(&_fr, register_map(), sv);
225+
stackChunkOop c = _reg_map.stack_chunk()();
226+
const_cast<RegisterMap*>(&_reg_map)->set_stack_chunk(_chunk());
227+
228+
StackValue* res = StackValue::create_stack_value(&_fr, register_map(), sv);
229+
230+
const_cast<RegisterMap*>(&_reg_map)->set_stack_chunk(c);
231+
return res;
225232
}
226233

227234
BasicLock* compiledVFrame::resolve_monitor_lock(Location location) const {

0 commit comments

Comments
 (0)
Please sign in to comment.