oop objVectorMap::cloneSize(oop obj, fint len, bool mustAllocate, oop filler) {
assert_objVector(obj, "not an obj vector");
fint l = objVectorOop(obj)->length();
objVectorOop v;
if (l < len) {
// growing array
v= objVectorOop(obj)->grow(len - l, mustAllocate);
if (oop(v) != failedAllocationOop) {
set_oops(v->objs(l), len - l, filler);
if (v->is_old()) {
if (filler->is_new()) {
// do all of object
Memory->remembered_set->record_multistores(v->oops(), v->objs(len));
} else {
// just do beginning of object; filler isn't new
Memory->remembered_set->record_multistores(v->oops(), v->objs(l));
}
}
}
} else if (l > len) {
// shrinking array
v= objVectorOop(obj)->shrink(l - len, mustAllocate);
} else {
// copying array
v= objVectorOop(obj)->copy(mustAllocate);
}
if (oop(v) != failedAllocationOop) v->init_mark();
return v;
}
oop objVectorOopClass::ov_at_put_prim(oop rcvr, oop indexOop, oop contents) {
if (!rcvr->is_objVector()) return ErrorCodes::vmString_prim_error(BADTYPEERROR);
if (!indexOop->is_smi()) return ErrorCodes::vmString_prim_error(BADTYPEERROR);
smi index = smiOop(indexOop)->value();
if (unsigned(index) >= unsigned(objVectorOop(rcvr)->length()))
return ErrorCodes::vmString_prim_error(BADINDEXERROR);
objVectorOop(rcvr)->obj_at_put(index, contents);
return rcvr;
}
void abstract_interpreter::check_branch_vector(abstract_interpreter *ai, oop) {
oop p= ai->get_literal();
if (ai->error_msg) return;
if (!p->is_objVector()) {
ai->set_error_msg( "branch vector must be object vector");
return;
}
objVectorOop v= objVectorOop(p);
for (int32 i = 0; i < v->length(); ++i) {
oop p= v->obj_at(i);
check_branch_target(ai, p);
if (ai->error_msg) return;
}
}
void graph_creator::do_edge(call_graph_edge* e) {
oop node_oop;
if (e->is_fold_edge()) {
node_oop = clone_fold_edge_pt((fold_edge*) e);
} else {
call_graph_node* n = e->callee;
if (n->is_method_node()) {
node_oop = clone_method_pt((method_node*) n);
} else if (n->is_block_node()) {
node_oop = clone_block_pt((block_node*) n);
} else if (n->is_prim_node()) {
node_oop = clone_prim_node_pt((prim_node*) n);
} else if (n->is_access_node()) {
node_oop = clone_access_node_pt((access_node*) n);
} else if (n->is_leaf_node()) {
node_oop = clone_leaf_node_pt((leaf_node*) n);
} else {
fatal("unexpected node type in call graph");
}
}
if (node_oop == failedAllocationOop) {
out_of_memory= true;
return;
}
if (parent) {
assert(parent->is_objVector(), "should be an objVector");
// fill in an element in the parent vector
objVectorOop p = objVectorOop(parent);
assert( p->obj_at(index * 2 ) == NULL, "already there\n");
assert( p->obj_at(index * 2 + 1) == NULL, "already there\n");
p->obj_at_put(index * 2, as_smiOop(e->bci));
p->obj_at_put(index * 2 + 1, node_oop);
index++;
}
else {
assert(_root == NULL, "_root already set");
_root = node_oop;
}
next_parent = node_oop;
}
void processOopClass::TWAINS_transfer_to_another_process(
Process* proc,
objVectorOop& resultArg,
bool stepping,
vframeOop stop_vfo) {
if (proc->hasStack() || proc->allocate()) {
// transfer to the other process
preserved pres1(resultArg);
if (stepping) {
proc->setSingleStepping();
preemptCause = cSingleStepped; // so it isn't overridden by signals
}
if (stop_vfo) proc->setStopPoint(stop_vfo);
LOG_EVENT3("TWAINS: transfer to %#lx %s stop=%#lx", proc,
stepping ? "stepping" : "", stop_vfo);
proc->transfer(); // run the other process
resultArg = objVectorOop(pres1.value);
if (stepping) {
assert(preemptCause == cSingleStepped ||
isFatalCause(preemptCause), "wrong preemptCause");
proc->resetSingleStepping();
}
if (proc->stopping) {
// returned from stopActivation (but could be way past it, e.g.
// when process was aborted)
proc->resetStopping();
if (!isFatalCause(preemptCause)) preemptCause = cFinishedActivation;
}
proc->setStopPoint(NULL);
} else {
// couldn't allocate stack
preemptCause= cCouldntAllocateStack;
proc->state= aborting;
}
}
void objVectorMap::dummy_initialize(oop obj, oop filler) {
Unused(filler);
assert_objVector(obj, "not an obj vector");
objVectorOop(obj)->set_length(0);
}
bool objVectorMap::verify(oop obj) {
return objVectorOop(obj)->verify();
}
oop objVectorMap::scavenge(oop obj) {
// use :: to avoid another virtual function call
return objVectorOop(obj)->scavenge(objVectorMap::object_size(obj));
}
oop objVectorMap::clone(oop obj, bool mustAllocate, oop genObj) {
assert_objVector(obj, "not an obj vector");
objVectorOop v= objVectorOop(obj)->copy(mustAllocate, genObj);
if (oop(v) != failedAllocationOop) v->init_mark();
return v;
}
oop objVectorOopClass::ov_size_prim(oop rcvr) {
if (!rcvr->is_objVector()) return ErrorCodes::vmString_prim_error(BADTYPEERROR);
return as_smiOop(objVectorOop(rcvr)->length());
}
