PUBLIC
L4_fpage::Rights
Vm_vmx_ept::v_delete(Mem_space::Vaddr virt, Mem_space::Page_order size,
L4_fpage::Rights page_attribs)
{
(void)size;
assert (cxx::get_lsb(Virt_addr(virt), size) == 0);
auto i = _ept->walk(virt);
if (EXPECT_FALSE (! i.is_valid()))
return L4_fpage::Rights(0);
L4_fpage::Rights ret = i.access_flags();
if (! (page_attribs & L4_fpage::Rights::R()))
{
// downgrade PDE (superpage) rights
i.del_rights(page_attribs);
}
else
{
// delete PDE (superpage)
i.clear();
}
return ret;
}
void next() {
if (access_flags().field_has_generic_signature()) {
_generic_signature_slot ++;
assert(_generic_signature_slot <= _fields->length(), "");
}
_index += 1;
}
void set_generic_signature_index(int index) {
assert(!field()->is_internal(), "regular only");
if (access_flags().field_has_generic_signature()) {
assert(_generic_signature_slot < _fields->length(), "out of bounds");
_fields->at_put(_generic_signature_slot, index);
}
}
Symbol* generic_signature() const {
if (access_flags().field_has_generic_signature()) {
assert(_generic_signature_slot < _fields->length(), "out of bounds");
int index = _fields->at(_generic_signature_slot);
return _constants->symbol_at(index);
} else {
return NULL;
}
}
int generic_signature_index() const {
assert(!field()->is_internal(), "regular only");
if (access_flags().field_has_generic_signature()) {
assert(_generic_signature_slot < _fields->length(), "out of bounds");
return _fields->at(_generic_signature_slot);
} else {
return 0;
}
}
bool is_static() const { return access_flags().is_static(); }
bool has_finalizer() const {
return access_flags().has_finalizer();
}
bool has_vanilla_constructor() const {
return access_flags().has_vanilla_constructor();
}
void ClassInfo::iterate(OopVisitor* visitor) {
#if USE_OOP_VISITOR
Oop::iterate(visitor);
{
NamedField id("object_size", true);
visitor->do_ushort(&id, object_size_offset(), true);
}
{
NamedField id("vtable_length", true);
visitor->do_ushort(&id, vtable_length_offset(), true);
}
{
NamedField id("itable_length", true);
visitor->do_ushort(&id, itable_length_offset(), true);
}
{
NamedField id("class_id", true);
visitor->do_ushort(&id, class_id_offset(), true);
}
{
NamedField id("name", true);
visitor->do_oop(&id, name_offset(), true);
}
{
char buff[1024];
access_flags().print_to_buffer(buff, AccessFlags::CLASS_FLAGS);
visitor->do_comment(buff);
NamedField id("access_flags", true);
id.set_hex_output(true);
visitor->do_uint(&id, access_flags_offset(), true);
}
if (is_array()) {
{
NamedField id("type", true);
visitor->do_int(&id, type_offset(), true);
}
{
NamedField id("scale", true);
visitor->do_int(&id, scale_offset(), true);
}
} else {
{
NamedField id("methods", true);
visitor->do_oop(&id, methods_offset(), true);
}
{
NamedField id("fields", true);
visitor->do_oop(&id, fields_offset(), true);
}
{
NamedField id("local_interfaces", true);
visitor->do_oop(&id, local_interfaces_offset(), true);
}
#if ENABLE_REFLECTION
{
NamedField id("inner_classes", true);
visitor->do_oop(&id, inner_classes_offset(), true);
}
#endif
{
NamedField id("constants", true);
visitor->do_oop(&id, constants_offset(), true);
}
}
iterate_tables(visitor);
#endif
}
bool is_package_private() const {
return access_flags().is_package_private();
}
bool is_synthetic() const { return access_flags().is_synthetic(); }
bool is_transient() const { return access_flags().is_transient(); }
bool is_volatile() const { return access_flags().is_volatile(); }
bool is_verified() const {
return access_flags().is_verified();
}
bool is_protected() const { return access_flags().is_protected(); }
// Access flags
bool is_public() const { return access_flags().is_public(); }
bool is_interface() const {
return access_flags().is_interface();
}
// Is this a ClassInfo for an ArrayClass?
bool is_array() {
return access_flags().is_array_class();
}
void set_has_vanilla_constructor() {
AccessFlags flags = access_flags();
flags.set_has_vanilla_constructor();
set_access_flags(flags);
}
void set_is_verified() {
AccessFlags flags = access_flags();
flags.set_is_verified();
set_access_flags(flags);
}
bool is_final() const { return access_flags().is_final(); }
bool is_abstract() const {
return access_flags().is_abstract();
}
