abstract_vframe* processOopClass::vframe_at(smi index, void *FH, Process*& p,
frame*& last) {
p = checkProcess(this);
if (!p) {
prim_failure(FH, NOPROCESSERROR);
return NULL;
}
if (index < 0 || !p->inSelf()) {
prim_failure(FH, BADINDEXERROR);
return NULL;
}
FlushRegisterWindows();
last = p->last_self_frame(false);
abstract_vframe* vf = new_vframe(last);
if (vf->is_prologue()) vf = vf->sender();
bool hideFirst = p != vmProcess;
int32 i = 0;
for ( ;; ) {
if (i == index) break;
vf = vf->sender();
i++;
if (!vf) break;
}
if (!vf || (vf->is_first_self_vframe() && hideFirst)) {
prim_failure(FH, BADINDEXERROR);
return NULL;
}
return vf;
}
char* sendDesc::sendMessage( frame* lookupFrame,
oop receiver,
oop perform_selector,
oop perform_delegatee,
oop arg1 ) {
ShowLookupInMonitor sl;
LookupType type= lookupType();
oop sel = static_or_dynamic_selector( perform_selector, type);
oop del = static_or_dynamic_delegatee( perform_delegatee, type);
sendMessagePrologue( receiver, lookupFrame );
if ( !Trace) {
// try codeTable first (order of magnitude faster)
char* r = fastCacheLookupAndBackpatch(type,
receiver->map()->enclosing_mapOop(),
sel,
del);
if (r) {
if (SilentTrace) LOG_EVENT1("SendMessage: fast-found %#lx", r);
return r;
}
}
// have to do it the slow way
ResourceMark m;
FlushRegisterWindows(); // for vframe conversion below
cacheProbingLookup L( receiver,
sel,
del,
MH_TBD, // method holder
new_vframe(lookupFrame),
this,
NULL, // DIDesc
false ); // don't want a debug version
// should we have switched stacks sooner? (dmu) also in SendDIMessage
nmethod* nm = switchToVMStack( SendMessage_cont, &L );
if (SilentTrace) LOG_EVENT1("sendDesc::sendMessage: found %#lx", nm);
return
Interpret
? L.interpretResultForCompiledSender(arg1)
: nm->verifiedEntryPoint();
}
frame* frame::make_full_frame_after_trap(char* pc) {
FlushRegisterWindows();
return make_full_frame(pc);
}
void frame::fix_frame( char* pc, char* sp) {
FlushRegisterWindows();
assert(isOnVMStack(this), "will be overwritten");
callees_sp()->set_link((sparc_fp*)sp);
set_real_return_addr(pc);
}
void NLRSupport::fix_current_return_address(char* addr) {
// make sure this function doesn't get inlined
FlushRegisterWindows();
currentFrame()->fix_current_return_address(addr);
}
oop processOopClass::ActivationStack_prim(void *FH) {
ResourceMark rm;
Process* p = checkProcess(this);
if (p == currentProcess)
p->killVFrameOopsAndSetWatermark( p->last_self_frame(false));
if (!p) {
prim_failure(FH, NOPROCESSERROR);
return NULL;
}
FlushRegisterWindows();
vframeBList = new VFrameBList(1000);
p->stack()->vframes_do(addVFrameToList);
bool hideFirst = p != vmProcess;
if (vframeBList->nonEmpty() && hideFirst) (void) vframeBList->pop();
smi len= vframeBList->length();
objVectorOop resultVec= Memory->objVectorObj->cloneSize(len, CANFAIL);
if (oop(resultVec) == failedAllocationOop) {
out_of_memory_failure(FH, Memory->objVectorObj->size() + len);
return NULL;
}
oop* resultp = resultVec->objs();
// Build the result as a merge of vframeBList and existing vframeOops
// and save mirrors of all the resulting vframeOops.
vframeOop prev = vframeList();
vframeOop merge = prev->next();
for (int i = 0; i < vframeBList->length(); i++) {
abstract_vframe* vf = vframeBList->nth(i);
mirrorOop mirror;
if (merge && merge->is_equal(vf)) {
mirror= merge->as_mirror_or_fail();
if (oop(mirror) == failedAllocationOop) {
out_of_memory_failure(FH);
return NULL;
}
prev = merge;
merge = merge->next();
} else {
vframeOop vfo= clone_vframeOop(vf, p, CANFAIL);
if (oop(vfo) == failedAllocationOop) {
out_of_memory_failure(FH);
return NULL;
}
mirror= vfo->as_mirror_or_fail();
if (oop(mirror) == failedAllocationOop) {
out_of_memory_failure(FH);
return NULL;
}
vfo->insertAfter(prev);
prev = vfo;
}
Memory->store(resultp++, mirror);
}
if (p == currentProcess)
p->killVFrameOopsAndSetWatermark( p->last_self_frame(false));
return resultVec;
}
