Mercurial > hg > graal-compiler
view src/share/vm/code/debugInfo.cpp @ 477:24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
Summary: Make reguard_stack change access to RW, not execute and use os::protect_memory with the new parameter when change needed to X.
Reviewed-by: acorn, jcoomes
author | coleenp |
---|---|
date | Wed, 10 Dec 2008 15:14:29 -0800 |
parents | d1605aabd0a1 |
children | c18cbe5936b8 |
line wrap: on
line source
/* * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, * CA 95054 USA or visit www.sun.com if you need additional information or * have any questions. * */ # include "incls/_precompiled.incl" # include "incls/_debugInfo.cpp.incl" // Comstructors DebugInfoWriteStream::DebugInfoWriteStream(DebugInformationRecorder* recorder, int initial_size) : CompressedWriteStream(initial_size) { _recorder = recorder; } // Serializing oops void DebugInfoWriteStream::write_handle(jobject h) { write_int(recorder()->oop_recorder()->find_index(h)); } ScopeValue* DebugInfoReadStream::read_object_value() { int id = read_int(); #ifdef ASSERT assert(_obj_pool != NULL, "object pool does not exist"); for (int i = _obj_pool->length() - 1; i >= 0; i--) { assert(((ObjectValue*) _obj_pool->at(i))->id() != id, "should not be read twice"); } #endif ObjectValue* result = new ObjectValue(id); // Cache the object since an object field could reference it. _obj_pool->push(result); result->read_object(this); return result; } ScopeValue* DebugInfoReadStream::get_cached_object() { int id = read_int(); assert(_obj_pool != NULL, "object pool does not exist"); for (int i = _obj_pool->length() - 1; i >= 0; i--) { ObjectValue* ov = (ObjectValue*) _obj_pool->at(i); if (ov->id() == id) { return ov; } } ShouldNotReachHere(); return NULL; } // Serializing scope values enum { LOCATION_CODE = 0, CONSTANT_INT_CODE = 1, CONSTANT_OOP_CODE = 2, CONSTANT_LONG_CODE = 3, CONSTANT_DOUBLE_CODE = 4, OBJECT_CODE = 5, OBJECT_ID_CODE = 6 }; ScopeValue* ScopeValue::read_from(DebugInfoReadStream* stream) { ScopeValue* result = NULL; switch(stream->read_int()) { case LOCATION_CODE: result = new LocationValue(stream); break; case CONSTANT_INT_CODE: result = new ConstantIntValue(stream); break; case CONSTANT_OOP_CODE: result = new ConstantOopReadValue(stream); break; case CONSTANT_LONG_CODE: result = new ConstantLongValue(stream); break; case CONSTANT_DOUBLE_CODE: result = new ConstantDoubleValue(stream); break; case OBJECT_CODE: result = stream->read_object_value(); break; case OBJECT_ID_CODE: result = stream->get_cached_object(); break; default: ShouldNotReachHere(); } return result; } // LocationValue LocationValue::LocationValue(DebugInfoReadStream* stream) { _location = Location(stream); } void LocationValue::write_on(DebugInfoWriteStream* stream) { stream->write_int(LOCATION_CODE); location().write_on(stream); } void LocationValue::print_on(outputStream* st) const { location().print_on(st); } // ObjectValue void ObjectValue::read_object(DebugInfoReadStream* stream) { _klass = read_from(stream); assert(_klass->is_constant_oop(), "should be constant klass oop"); int length = stream->read_int(); for (int i = 0; i < length; i++) { ScopeValue* val = read_from(stream); _field_values.append(val); } } void ObjectValue::write_on(DebugInfoWriteStream* stream) { if (_visited) { stream->write_int(OBJECT_ID_CODE); stream->write_int(_id); } else { _visited = true; stream->write_int(OBJECT_CODE); stream->write_int(_id); _klass->write_on(stream); int length = _field_values.length(); stream->write_int(length); for (int i = 0; i < length; i++) { _field_values.at(i)->write_on(stream); } } } void ObjectValue::print_on(outputStream* st) const { st->print("obj[%d]", _id); } void ObjectValue::print_fields_on(outputStream* st) const { #ifndef PRODUCT if (_field_values.length() > 0) { _field_values.at(0)->print_on(st); } for (int i = 1; i < _field_values.length(); i++) { st->print(", "); _field_values.at(i)->print_on(st); } #endif } // ConstantIntValue ConstantIntValue::ConstantIntValue(DebugInfoReadStream* stream) { _value = stream->read_signed_int(); } void ConstantIntValue::write_on(DebugInfoWriteStream* stream) { stream->write_int(CONSTANT_INT_CODE); stream->write_signed_int(value()); } void ConstantIntValue::print_on(outputStream* st) const { st->print("%d", value()); } // ConstantLongValue ConstantLongValue::ConstantLongValue(DebugInfoReadStream* stream) { _value = stream->read_long(); } void ConstantLongValue::write_on(DebugInfoWriteStream* stream) { stream->write_int(CONSTANT_LONG_CODE); stream->write_long(value()); } void ConstantLongValue::print_on(outputStream* st) const { st->print(INT64_FORMAT, value()); } // ConstantDoubleValue ConstantDoubleValue::ConstantDoubleValue(DebugInfoReadStream* stream) { _value = stream->read_double(); } void ConstantDoubleValue::write_on(DebugInfoWriteStream* stream) { stream->write_int(CONSTANT_DOUBLE_CODE); stream->write_double(value()); } void ConstantDoubleValue::print_on(outputStream* st) const { st->print("%f", value()); } // ConstantOopWriteValue void ConstantOopWriteValue::write_on(DebugInfoWriteStream* stream) { stream->write_int(CONSTANT_OOP_CODE); stream->write_handle(value()); } void ConstantOopWriteValue::print_on(outputStream* st) const { JNIHandles::resolve(value())->print_value_on(st); } // ConstantOopReadValue ConstantOopReadValue::ConstantOopReadValue(DebugInfoReadStream* stream) { _value = Handle(stream->read_oop()); } void ConstantOopReadValue::write_on(DebugInfoWriteStream* stream) { ShouldNotReachHere(); } void ConstantOopReadValue::print_on(outputStream* st) const { value()()->print_value_on(st); } // MonitorValue MonitorValue::MonitorValue(ScopeValue* owner, Location basic_lock, bool eliminated) { _owner = owner; _basic_lock = basic_lock; _eliminated = eliminated; } MonitorValue::MonitorValue(DebugInfoReadStream* stream) { _basic_lock = Location(stream); _owner = ScopeValue::read_from(stream); _eliminated = (stream->read_bool() != 0); } void MonitorValue::write_on(DebugInfoWriteStream* stream) { _basic_lock.write_on(stream); _owner->write_on(stream); stream->write_bool(_eliminated); } #ifndef PRODUCT void MonitorValue::print_on(outputStream* st) const { st->print("monitor{"); owner()->print_on(st); st->print(","); basic_lock().print_on(st); st->print("}"); if (_eliminated) { st->print(" (eliminated)"); } } #endif