void GarbageCollector::visit_call_frame(CallFrame* top_call_frame, ObjectVisitor& visit) {
CallFrame* call_frame = top_call_frame;
while(call_frame) {
if(call_frame->custom_static_scope_p() &&
call_frame->static_scope_ &&
call_frame->static_scope_->reference_p()) {
call_frame->static_scope_ =
(StaticScope*)visit.call(call_frame->static_scope_);
}
if(call_frame->cm && call_frame->cm->reference_p()) {
call_frame->cm = (CompiledMethod*)visit.call(call_frame->cm);
}
if(call_frame->cm && call_frame->stk) {
native_int stack_size = call_frame->cm->stack_size()->to_native();
for(native_int i = 0; i < stack_size; i++) {
Object* obj = call_frame->stk[i];
if(obj && obj->reference_p()) {
call_frame->stk[i] = visit.call(obj);
}
}
}
if(call_frame->multiple_scopes_p() &&
call_frame->top_scope_) {
call_frame->top_scope_ = (VariableScope*)visit.call(call_frame->top_scope_);
}
visit_variable_scope(call_frame, call_frame->scope, visit);
call_frame = static_cast<CallFrame*>(call_frame->previous);
}
}
void CompiledMethod::Info::visit(Object* obj, ObjectVisitor& visit) {
auto_visit(obj, visit);
visit_inliners(obj, visit);
CompiledMethod* cm = as<CompiledMethod>(obj);
if(!cm->backend_method_) return;
VMMethod* vmm = cm->backend_method_;
#ifdef ENABLE_LLVM
if(cm->jit_data()) {
cm->jit_data()->visit_all(visit);
}
for(int i = 0; i < VMMethod::cMaxSpecializations; i++) {
if(vmm->specializations[i].jit_data) {
vmm->specializations[i].jit_data->visit_all(visit);
}
}
#endif
for(size_t i = 0; i < vmm->inline_cache_count(); i++) {
InlineCache* cache = &vmm->caches[i];
MethodCacheEntry* mce = cache->cache_;
if(mce) visit.call(mce);
for(int i = 0; i < cTrackedICHits; i++) {
Module* mod = cache->seen_classes_[i].klass();
if(mod) visit.call(mod);
}
}
}
void RuntimeDataHolder::visit_all(ObjectVisitor& visit) {
for(std::list<jit::RuntimeData*>::iterator i = runtime_data_.begin();
i != runtime_data_.end();
++i) {
jit::RuntimeData* rd = *i;
visit.call(rd->method());
visit.call(rd->name());
visit.call(rd->module());
}
}
void VariableScope::Info::visit(Object* obj, ObjectVisitor& visit) {
auto_visit(obj, visit);
VariableScope* vs = as<VariableScope>(obj);
if(!vs->isolated()) {
Object** ary = vs->stack_locals();
if(Fiber* fib = try_as<Fiber>(vs->fiber())) {
FiberData* data = fib->data();
AddressDisplacement dis(data->data_offset(),
data->data_lower_bound(),
data->data_upper_bound());
ary = dis.displace(ary);
}
size_t locals = vs->number_of_locals();
for(size_t i = 0; i < locals; i++) {
visit.call(ary[i]);
}
}
}
void Tuple::Info::visit(Object* obj, ObjectVisitor& visit) {
Tuple* tup = as<Tuple>(obj);
for(size_t i = 0; i < tup->num_fields(); i++) {
visit.call(tup->field[i]);
}
}
void Executable::Info::visit_inliners(Object* obj, ObjectVisitor& visit) {
Executable* exc = (Executable*)obj;
if(!exc->inliners_ || exc->inliners_ == (Inliners*)cNil) return;
for(std::list<CompiledMethod*>::iterator i = exc->inliners_->inliners().begin();
i != exc->inliners_->inliners().end();
++i) {
visit.call(*i);
}
}
void SendSite::Info::visit(Object* obj, ObjectVisitor& visit) {
auto_visit(obj, visit);
SendSite* ss = as<SendSite>(obj);
if(ss->inner_cache_) {
SendSite::Internal* cache = ss->inner_cache_;
if(cache->module) {
visit.call(cache->module);
}
if(cache->method) {
visit.call(cache->method);
}
if(cache->recv_class) {
visit.call(cache->recv_class);
}
}
}
void PackedObject::Info::visit(Object* obj, ObjectVisitor& visit) {
PackedObject* po = reinterpret_cast<PackedObject*>(obj);
size_t fields = to_fields(object_size(obj));
Object** body = po->body_as_array();
for(size_t i = 0; i < fields; i++) {
visit.call(body[i]);
}
}
void VariableScope::Info::visit(Object* obj, ObjectVisitor& visit) {
auto_visit(obj, visit);
VariableScope* vs = as<VariableScope>(obj);
size_t locals = vs->number_of_locals();
for(size_t i = 0; i < locals; i++) {
visit.call(vs->get_local(i));
}
}
void GarbageCollector::visit_roots(Roots& roots, ObjectVisitor& visit) {
Root* root = static_cast<Root*>(roots.head());
while(root) {
Object* tmp = root->get();
if(tmp->reference_p()) {
visit.call(tmp);
}
root = static_cast<Root*>(root->next());
}
}
void GarbageCollector::visit_variable_scope(CallFrame* call_frame,
StackVariables* scope, ObjectVisitor& visit)
{
scope->self_ = visit.call(scope->self());
scope->block_ = visit.call(scope->block());
scope->module_ = (Module*)visit.call(scope->module());
int locals = call_frame->cm->backend_method()->number_of_locals;
for(int i = 0; i < locals; i++) {
Object* local = scope->get_local(i);
if(local->reference_p()) {
scope->set_local(i, visit.call(local));
}
}
VariableScope* parent = scope->parent();
if(parent && parent->reference_p()) {
scope->parent_ = ((VariableScope*)visit.call(parent));
}
VariableScope* on_heap = scope->on_heap();
if(on_heap) {
scope->on_heap_ = ((VariableScope*)visit.call(on_heap));
}
}
void VariableScope::Info::visit(Object* obj, ObjectVisitor& visit) {
auto_visit(obj, visit);
VariableScope* vs = as<VariableScope>(obj);
if(!vs->isolated()) {
Object** ary = vs->stack_locals();
size_t locals = vs->number_of_locals();
for(size_t i = 0; i < locals; i++) {
visit.call(ary[i]);
}
}
}
void Regexp::Info::visit(Object* obj, ObjectVisitor& visit) {
auto_visit(obj, visit);
Regexp* reg_o = force_as<Regexp>(obj);
regex_t* reg = reg_o->onig_data;
if(!reg) return;
ByteArray* reg_ba = ByteArray::from_body(reg);
visit.call(reg_ba);
if(reg->p) {
ByteArray* ba = ByteArray::from_body(reg->p);
visit.call(ba);
}
if(reg->exact) {
ByteArray* ba = ByteArray::from_body(reg->exact);
visit.call(ba);
}
if(reg->int_map) {
ByteArray* ba = ByteArray::from_body(reg->int_map);
visit.call(ba);
}
if(reg->int_map_backward) {
ByteArray* ba = ByteArray::from_body(reg->int_map_backward);
visit.call(ba);
}
if(reg->repeat_range) {
ByteArray* ba = ByteArray::from_body(reg->repeat_range);
visit.call(ba);
}
}
