int associationKlass::oop_scavenge_contents(oop obj) {
int size = non_indexable_size();
// header + instance variables
memOop(obj)->scavenge_header();
memOop(obj)->scavenge_body(memOopDesc::header_size(), size);
return size;
}
memOop MarkSweep::reverse(oop* p) {
oop obj = *p;
// Return NULL if non memOop
if (!obj->is_mem()) return NULL;
if (memOop(obj)->is_gc_marked()) {
// Reverse pointer
*p = oop(memOop(obj)->mark());
memOop(obj)->set_mark(p);
return NULL;
} else {
// Before the pointer reversal takes place the object size must be made accessible
// without using the klass pointer. We store the object size partially in the
// age field and partially in the remembered set.
memOop(obj)->gc_store_size();
assert(memOop(obj)->size() == memOop(obj)->gc_retrieve_size(), "checking real against stored size");
// Reverse pointer
*p = oop(memOop(obj)->mark());
memOop(obj)->set_mark(p);
assert(memOop(obj)->klass()->is_mem(), "just checking");
return memOop(obj);
}
}
PRIM_DECL_2(doubleByteArrayPrimitives::allocateSize, oop receiver, oop argument) {
PROLOGUE_2("allocateSize", receiver, argument)
assert(receiver->is_klass() && klassOop(receiver)->klass_part()->oop_is_doubleByteArray(),
"receiver must double byte array class");
if (!argument->is_smi())
markSymbol(vmSymbols::first_argument_has_wrong_type());
if (smiOop(argument)->value() < 0)
return markSymbol(vmSymbols::negative_size());
klassOop k = klassOop(receiver);
int ni_size = k->klass_part()->non_indexable_size();
int obj_size = ni_size + 1 + roundTo(smiOop(argument)->value() * 2, oopSize) / oopSize;
// allocate
doubleByteArrayOop obj = as_doubleByteArrayOop(Universe::allocate(obj_size, (memOop*)&k));
// header
memOop(obj)->initialize_header(true, k);
// instance variables
memOop(obj)->initialize_body(memOopDesc::header_size(), ni_size);
// indexables
oop* base = (oop*) obj->addr();
oop* end = base + obj_size;
// %optimized 'obj->set_length(size)'
base[ni_size] = argument;
// %optimized 'for (int index = 1; index <= size; index++)
// obj->doubleByte_at_put(index, 0)'
base = &base[ni_size+1];
while (base < end) *base++ = (oop) 0;
return obj;
}
oop doubleByteArrayKlass::allocateObjectSize(int size, bool permit_scavenge, bool tenured) {
klassOop k = as_klassOop();
int ni_size = non_indexable_size();
int obj_size = ni_size + 1 + roundTo(size * 2, oopSize) / oopSize;
// allocate
oop* result = tenured ?
Universe::allocate_tenured(obj_size, permit_scavenge) :
Universe::allocate(obj_size, (memOop*)&k, permit_scavenge);
if (result == NULL) return NULL;
doubleByteArrayOop obj = as_doubleByteArrayOop(result);
// header
memOop(obj)->initialize_header(true, k);
// instance variables
memOop(obj)->initialize_body(memOopDesc::header_size(), ni_size);
// indexables
oop* base = (oop*) obj->addr();
oop* end = base + obj_size;
// %optimized 'obj->set_length(size)'
base[ni_size] = as_smiOop(size);
// %optimized 'for (int index = 1; index <= size; index++)
// obj->doubleByte_at_put(index, 0)'
base = &base[ni_size+1];
while (base < end) *base++ = (oop) 0;
return obj;
}
PRIM_DECL_2(doubleValueArrayPrimitives::allocateSize, oop receiver, oop argument) {
PROLOGUE_2("allocateSize", receiver, argument)
assert(receiver->is_klass() && klassOop(receiver)->klass_part()->oop_is_doubleValueArray(),
"receiver must double byte array class");
if (!argument->is_smi())
markSymbol(vmSymbols::first_argument_has_wrong_type());
if (smiOop(argument)->value() < 0)
return markSymbol(vmSymbols::negative_size());
int length = smiOop(argument)->value();
klassOop k = klassOop(receiver);
int ni_size = k->klass_part()->non_indexable_size();
int obj_size = ni_size + 1 + roundTo(length * sizeof(double), oopSize) / oopSize;
// allocate
doubleValueArrayOop obj = as_doubleValueArrayOop(Universe::allocate(obj_size, (memOop*)&k));
// header
memOop(obj)->initialize_header(true, k);
// instance variables
memOop(obj)->initialize_body(memOopDesc::header_size(), ni_size);
obj->set_length(length);
for (int index = 1; index <= length; index++) {
obj->double_at_put(index, 0.0);
}
return obj;
}
int memOopKlass::oop_scavenge_tenured_contents(oop obj) {
int size = non_indexable_size();
// header
memOop(obj)->scavenge_tenured_header();
// instance variables
memOop(obj)->scavenge_tenured_body(memOopDesc::header_size(), size);
return size;
}
void associationKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
// header
memOop(obj)->oop_iterate_header(blk);
associationOop assoc = associationOop(obj);
blk->do_oop((oop*) &assoc->addr()->_key);
blk->do_oop((oop*) &assoc->addr()->_value);
blk->do_oop((oop*) &assoc->addr()->_is_constant);
// instance variables
memOop(obj)->oop_iterate_body(blk, associationOopDesc::header_size(), non_indexable_size());
}
void mixinKlass::oop_layout_iterate(oop obj, ObjectLayoutClosure* blk) {
// header
memOop(obj)->layout_iterate_header(blk);
blk->do_oop("methods", (oop*)&mixinOop(obj)->addr()->_methods);
blk->do_oop("instVars", (oop*)&mixinOop(obj)->addr()->_inst_vars);
blk->do_oop("classVars", (oop*)&mixinOop(obj)->addr()->_class_vars);
blk->do_oop("primary invocation", (oop*)&mixinOop(obj)->addr()->_primary_invocation);
blk->do_oop("class mixin", (oop*)&mixinOop(obj)->addr()->_class_mixin);
// instance variables
memOop(obj)->layout_iterate_body(blk, mixinOopDesc::header_size(), non_indexable_size());
}
void bootstrap::parse_file() {
// Check version number
int version_number = get_integer();
if (version_number > 100) {
_new_format = true;
lprintf(", n");
version_number -= 100;
} else {
_new_format = false;
}
if (Bytecodes::version() == version_number) {
} else {
lprintf("\n");
lprintf("Bytecode version conflict\n");
lprintf(" excpected: %d\n", Bytecodes::version());
lprintf(" received: %d\n", version_number);
exit(-1);
}
Universe::_systemDictionaryObj = objArrayOop(get_object());
nilObj = memOop(get_object());
trueObj = memOop(get_object());
falseObj = memOop(get_object());
smiKlassObj = klassOop(get_object());
Universe::_memOopKlassObj = klassOop(get_object());
Universe::_objArrayKlassObj = klassOop(get_object());
Universe::_byteArrayKlassObj = klassOop(get_object());
symbolKlassObj = klassOop(get_object());
doubleKlassObj = klassOop(get_object());
Universe::_methodKlassObj = klassOop(get_object());
Universe::_associationKlassObj = klassOop(get_object());
zeroArgumentBlockKlassObj = klassOop(get_object());
oneArgumentBlockKlassObj = klassOop(get_object());
twoArgumentBlockKlassObj = klassOop(get_object());
threeArgumentBlockKlassObj = klassOop(get_object());
fourArgumentBlockKlassObj = klassOop(get_object());
fiveArgumentBlockKlassObj = klassOop(get_object());
sixArgumentBlockKlassObj = klassOop(get_object());
sevenArgumentBlockKlassObj = klassOop(get_object());
eightArgumentBlockKlassObj = klassOop(get_object());
nineArgumentBlockKlassObj = klassOop(get_object());
contextKlassObj = klassOop(get_object());
Universe::_asciiCharacters = objArrayOop(get_object());
Universe::_vframeKlassObj = HasActivationClass ? klassOop(get_object()) : klassOop(nilObj);
klassOop platform_klass = klassOop(Universe::find_global(os::platform_class_name()));
associationOop assoc = Universe::find_global_association("Platform");
if (platform_klass != NULL && assoc != NULL) {
assoc->set_value(platform_klass);
}
}
int32 MethodLookupKey::hash() {
int32 i;
// Coded for speed - called for every codeTable lookup
// XOR the identity-hash values of the fields. For efficiency, just
// xor the marks and extract hash bits at the end instead of doing
// this for every field.
// Also, don't need to check for no_hash: real keys are guaranteed
// to have an id hash value because init_hash is called before a
// key is added to the table. If a lookup key contains oops with
// no_hash, we'll have a bogus hash value, but we won't find anything
// anyway.
i = (int32)receiverMapOop()->mark();
if (selector->is_mem())
i ^= (int32)memOop(selector)->mark();
// Can't do the optimization for the methodHolder - it might be
// e.g. a smiOop in the lookupError glue method.
// Not non-zero often enough to hash on
// (an optimization for speed; Bay's idea)
// i ^= (int32)delegatee ->mark();
return (lookupType & ~ImplicitSelfBit)
^ markOop(i)->hash()
^ methodHolder_or_map()->identity_hash();
}
void memOopClass::print_string(char* buf) {
if (this == memOop(badOop)) {
sprintf(buf, "badOop");
}
else
map()->print_string(this, buf);
}
void memOopClass::print_oop() {
if (this == memOop(badOop)) {
lprintf("badOop");
}
else
map()->print_oop(this);
}
objArrayOop objArrayKlass::allocate_tenured_pic(int size) {
klassOop k = Universe::objArrayKlassObj();
int ni_size = k->klass_part()->non_indexable_size();
int obj_size = ni_size + 1 + size;
// allocate
objArrayOop obj = as_objArrayOop(Universe::allocate_tenured(obj_size));
// header
memOop(obj)->initialize_header(k->klass_part()->has_untagged_contents(), k);
// instance variables
memOop(obj)->initialize_body(memOopDesc::header_size(), ni_size);
// indexables
oop* base = (oop*) obj->addr();
oop* end = base + obj_size;
// %optimized 'obj->set_length(size)'
base[ni_size] = as_smiOop(size);
memOop(obj)->initialize_body(ni_size+1, obj_size);
return obj;
}
oop mixinKlass::allocateObject(bool permit_scavenge, bool tenured) {
klassOop k = as_klassOop();
int size = non_indexable_size();
// allocate
oop* result = basicAllocate(size, &k, permit_scavenge, tenured);
if (result == NULL)
return NULL;
mixinOop obj = as_mixinOop(result);
// header + instance variables
memOop(obj)->initialize_header(true, k);
memOop(obj)->initialize_body(memOopDesc::header_size(), size);
objArrayOop filler = oopFactory::new_objArray(0);
obj->set_methods(filler);
obj->set_instVars(filler);
obj->set_classVars(filler);
obj->set_installed(falseObj);
return obj;
}
oop byteArrayKlass::allocateObjectSize(int size) {
klassOop k = as_klassOop();
int ni_size = non_indexable_size();
int obj_size = ni_size + 1 + roundTo(size, oopSize) / oopSize;
// allocate
byteArrayOop obj = as_byteArrayOop(Universe::allocate(obj_size, (memOop*)&k));
// header
memOop(obj)->initialize_header(true, k);
// instance variables
memOop(obj)->initialize_body(memOopDesc::header_size(), ni_size);
// indexables
oop* base = (oop*) obj->addr();
oop* end = base + obj_size;
// %optimized 'obj->set_length(size)'
base[ni_size] = as_smiOop(size);
// %optimized 'for (int index = 1; index <= size; index++)
// obj->byte_at_put(index, '\000')'
base = &base[ni_size+1];
while (base < end) *base++ = (oop) 0;
return obj;
}
void memOopKlass::oop_print_value_on(oop obj, outputStream* st) {
if (obj == nilObj) st->print("nil");
else if (obj == trueObj) st->print("true");
else if (obj == falseObj) st->print("false");
else {
if (PrintObjectID) {
memOop(obj)->print_id_on(st);
st->print("-");
}
print_name_on(st);
}
if (PrintOopAddress) st->print(" (%#x)", this);
}
oop memOopKlass::oop_shallow_copy(oop obj, bool tenured) {
// Do not copy oddballs (nil, true, false)
if (obj == nilObj) return obj;
if (obj == trueObj) return obj;
if (obj == falseObj) return obj;
int len = memOop(obj)->size();
// Important to preserve obj (in case of scavenge).
oop* clone = tenured ? Universe::allocate_tenured(len) : Universe::allocate(len, (memOop*)&obj);
oop* to = clone;
oop* from = (oop*) memOop(obj)->addr();
oop* end = to + len;
while (to < end) *to++ = *from++;
if (!as_memOop(clone)->is_new()) {
// Remember to update the remembered set if the clone is in old space.
// Note:
// should we do something special for arrays.
Universe::remembered_set->record_store(clone);
}
return as_memOop(clone);
}
oop InterpretedIC::does_not_understand(oop receiver, InterpretedIC* ic, frame* f) {
memOop msg;
symbolOop sel;
{
// message not understood...
BlockScavenge bs; // make sure that no scavenge happens
klassOop msgKlass = klassOop(Universe::find_global("Message"));
oop obj = msgKlass->klass_part()->allocateObject();
assert(obj->is_mem(), "just checkin'...");
msg = memOop(obj);
int nofArgs = ic->selector()->number_of_arguments();
objArrayOop args = oopFactory::new_objArray(nofArgs);
for (int i = 1; i <= nofArgs; i++) {
args->obj_at_put(i, f->expr(nofArgs - i));
}
// for now: assume instance variables are there...
// later: should check this or use a VM interface:
// msg->set_receiver(recv);
// msg->set_selector(ic->selector());
// msg->set_arguments(args);
msg->raw_at_put(2, receiver);
msg->raw_at_put(3, ic->selector());
msg->raw_at_put(4, args);
sel = oopFactory::new_symbol("doesNotUnderstand:");
if (interpreter_normal_lookup(receiver->klass(), sel).is_empty()) {
// doesNotUnderstand: not found ==> process error
{ ResourceMark rm;
std->print("LOOKUP ERROR\n");
sel->print_value(); std->print(" not found\n");
}
if (DeltaProcess::active()->is_scheduler()) {
DeltaProcess::active()->trace_stack();
fatal("lookup error in scheduler");
} else {
DeltaProcess::active()->suspend(::lookup_error);
}
ShouldNotReachHere();
}
}
// return marked result of doesNotUnderstand: message
return Delta::call(receiver, sel, msg);
// Solution: use an nmethod-like stub-routine called from
// within a (possibly one-element) PIC (in order to keep
// the method selector in the IC. That stub does the
// Delta:call and pops the right number of arguments
// taken from the selector (the no. of arguments from
// the selector can be optimized).
}
oop associationKlass::allocateObject(bool permit_scavenge, bool tenured) {
klassOop k = as_klassOop();
int size = non_indexable_size();
// allocate
oop* result = Universe::allocate_tenured(size, permit_scavenge);
if (result == NULL && !permit_scavenge) return NULL;
associationOop obj = as_associationOop(result);
// header
memOop(obj)->initialize_header(has_untagged_contents(), k);
obj->set_key(symbolOop(nilObj));
obj->set_value(nilObj);
obj->set_is_constant(false);
// instance variables
obj->initialize_body(associationOopDesc::header_size(), size);
return obj;
}
void WeakArrayRegister::scavenge_check_for_dying_objects() {
NotificationQueue::mark_elements();
for(int index = 0; index < weakArrays->length(); index++) {
weakArrayOop w = weakArrays->at(index);
bool encounted_near_death_objects = false;
for(int i = 1; i <= w->length(); i++) {
oop obj = w->obj_at(i);
if (scavenge_is_near_death(obj)) {
encounted_near_death_objects = true;
memOop(obj)->mark_as_dying();
}
}
if (encounted_near_death_objects && !w->is_queued())
NotificationQueue::put(w);
}
NotificationQueue::clear_elements();
}
void WeakArrayRegister::mark_sweep_check_for_dying_objects() {
for(int index = 0; index < weakArrays->length(); index++) {
weakArrayOop w = weakArrays->at(index);
int non_indexable_size = nis->at(index);
bool encounted_near_death_objects = false;
int length = smiOop(w->raw_at(non_indexable_size))->value();
for(int i = 1; i <= length; i++) {
oop obj = w->raw_at(non_indexable_size+i);
if (mark_sweep_is_near_death(obj)) {
encounted_near_death_objects = true;
memOop(obj)->mark_as_dying();
}
}
if (encounted_near_death_objects)
NotificationQueue::put_if_absent(w);
}
}
void associationKlass::oop_print_value_on(oop obj, outputStream* st) {
associationOop assoc = associationOop(obj);
if (PrintObjectID) {
memOop(obj)->print_id_on(st);
st->print("-");
}
print_name_on(st);
st->print(" {");
assoc->key()->print_symbol_on(st);
st->print(", ");
assoc->value()->print_value_on(st);
if (assoc->is_constant()) {
st->print(" (constant)");
}
st->print("}");
if (PrintOopAddress) st->print(" (%#x)", this);
}
bool associationKlass::oop_verify(oop obj) {
bool flag = memOop(obj)->verify();
return flag;
}
void associationKlass::oop_follow_contents(oop obj) {
// header + instance variables
memOop(obj)->follow_header();
memOop(obj)->follow_body(memOopDesc::header_size(), non_indexable_size());
}
memOop as_memOop() {
assert(Handles::oop_at(index)->is_mem(), "type check");
return memOop(Handles::oop_at(index));
}
inline bool newGeneration::is_new(oop p, char *boundary) {
return p->is_mem() && is_new(memOop(p), boundary);
}
void memOopKlass::oop_print_on(oop obj, outputStream* st) {
PrintObjectClosure blk(st);
blk.do_object(memOop(obj));
memOop(obj)->layout_iterate(&blk);
}
void pr(void* m) {
Command c("pr");
Universe::remembered_set->print_set_for_object(memOop(m));
}
bool memOopKlass::oop_verify(oop obj) {
return Universe::verify_oop(memOop(obj));
}
void memOopKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
// header
memOop(obj)->oop_iterate_header(blk);
// instance variables
memOop(obj)->oop_iterate_body(blk, memOopDesc::header_size(), non_indexable_size());
}
