Mercurial > hg > graal-compiler
view src/share/vm/classfile/stackMapTableFormat.hpp @ 10503:2393c37d1997
Merge
author | Christos Kotselidis <christos.kotselidis@oracle.com> |
---|---|
date | Fri, 21 Jun 2013 23:12:51 +0200 |
parents | 4ee06e614636 |
children |
line wrap: on
line source
/* * Copyright (c) 2010, 2012, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef SHARE_VM_CLASSFILE_STACKMAPTABLEFORMAT_HPP #define SHARE_VM_CLASSFILE_STACKMAPTABLEFORMAT_HPP #include "classfile/verificationType.hpp" // These classes represent the stack-map substructures described in the JVMS // (hence the non-conforming naming scheme). // These classes work with the types in their compressed form in-place (as they // would appear in the classfile). No virtual methods or fields allowed. class verification_type_info { private: // u1 tag // u2 cpool_index || u2 bci (for ITEM_Object & ITEM_Uninitailized only) address tag_addr() const { return (address)this; } address cpool_index_addr() const { return tag_addr() + sizeof(u1); } address bci_addr() const { return cpool_index_addr(); } protected: // No constructors - should be 'private', but GCC issues a warning if it is verification_type_info() {} verification_type_info(const verification_type_info&) {} public: static verification_type_info* at(address addr) { return (verification_type_info*)addr; } static verification_type_info* create_at(address addr, u1 tag) { verification_type_info* vti = (verification_type_info*)addr; vti->set_tag(tag); return vti; } static verification_type_info* create_object_at(address addr, u2 cp_idx) { verification_type_info* vti = (verification_type_info*)addr; vti->set_tag(ITEM_Object); vti->set_cpool_index(cp_idx); return vti; } static verification_type_info* create_uninit_at(address addr, u2 bci) { verification_type_info* vti = (verification_type_info*)addr; vti->set_tag(ITEM_Uninitialized); vti->set_bci(bci); return vti; } static size_t calculate_size(u1 tag) { if (tag == ITEM_Object || tag == ITEM_Uninitialized) { return sizeof(u1) + sizeof(u2); } else { return sizeof(u1); } } static size_t max_size() { return sizeof(u1) + sizeof(u2); } u1 tag() const { return *(u1*)tag_addr(); } void set_tag(u1 tag) { *((u1*)tag_addr()) = tag; } bool is_object() const { return tag() == ITEM_Object; } bool is_uninitialized() const { return tag() == ITEM_Uninitialized; } u2 cpool_index() const { assert(is_object(), "This type has no cp_index"); return Bytes::get_Java_u2(cpool_index_addr()); } void set_cpool_index(u2 idx) { assert(is_object(), "This type has no cp_index"); Bytes::put_Java_u2(cpool_index_addr(), idx); } u2 bci() const { assert(is_uninitialized(), "This type has no bci"); return Bytes::get_Java_u2(bci_addr()); } void set_bci(u2 bci) { assert(is_uninitialized(), "This type has no bci"); Bytes::put_Java_u2(bci_addr(), bci); } void copy_from(verification_type_info* from) { set_tag(from->tag()); if (from->is_object()) { set_cpool_index(from->cpool_index()); } else if (from->is_uninitialized()) { set_bci(from->bci()); } } size_t size() const { return calculate_size(tag()); } verification_type_info* next() { return (verification_type_info*)((address)this + size()); } // This method is used when reading unverified data in order to ensure // that we don't read past a particular memory limit. It returns false // if any part of the data structure is outside the specified memory bounds. bool verify(address start, address end) { return ((address)this >= start && (address)this < end && (bci_addr() + sizeof(u2) <= end || !is_object() && !is_uninitialized())); } void print_on(outputStream* st) { switch (tag()) { case ITEM_Top: st->print("Top"); break; case ITEM_Integer: st->print("Integer"); break; case ITEM_Float: st->print("Float"); break; case ITEM_Double: st->print("Double"); break; case ITEM_Long: st->print("Long"); break; case ITEM_Null: st->print("Null"); break; case ITEM_UninitializedThis: st->print("UninitializedThis"); break; case ITEM_Uninitialized: st->print("Uninitialized[#%d]", bci()); break; case ITEM_Object: st->print("Object[#%d]", cpool_index()); break; default: assert(false, "Bad verification_type_info"); } } }; #define FOR_EACH_STACKMAP_FRAME_TYPE(macro, arg1, arg2) \ macro(same_frame, arg1, arg2) \ macro(same_frame_extended, arg1, arg2) \ macro(same_locals_1_stack_item_frame, arg1, arg2) \ macro(same_locals_1_stack_item_extended, arg1, arg2) \ macro(chop_frame, arg1, arg2) \ macro(append_frame, arg1, arg2) \ macro(full_frame, arg1, arg2) #define SM_FORWARD_DECL(type, arg1, arg2) class type; FOR_EACH_STACKMAP_FRAME_TYPE(SM_FORWARD_DECL, x, x) #undef SM_FORWARD_DECL class stack_map_frame { protected: address frame_type_addr() const { return (address)this; } // No constructors - should be 'private', but GCC issues a warning if it is stack_map_frame() {} stack_map_frame(const stack_map_frame&) {} public: static stack_map_frame* at(address addr) { return (stack_map_frame*)addr; } stack_map_frame* next() const { return at((address)this + size()); } u1 frame_type() const { return *(u1*)frame_type_addr(); } void set_frame_type(u1 type) { *((u1*)frame_type_addr()) = type; } // pseudo-virtual methods inline size_t size() const; inline int offset_delta() const; inline void set_offset_delta(int offset_delta); inline int number_of_types() const; // number of types contained in the frame inline verification_type_info* types() const; // pointer to first type inline bool is_valid_offset(int offset_delta) const; // This method must be used when reading unverified data in order to ensure // that we don't read past a particular memory limit. It returns false // if any part of the data structure is outside the specified memory bounds. inline bool verify(address start, address end) const; inline void print_on(outputStream* st, int current_offset) const; // Create as_xxx and is_xxx methods for the subtypes #define FRAME_TYPE_DECL(stackmap_frame_type, arg1, arg2) \ inline stackmap_frame_type* as_##stackmap_frame_type() const; \ bool is_##stackmap_frame_type() { \ return as_##stackmap_frame_type() != NULL; \ } FOR_EACH_STACKMAP_FRAME_TYPE(FRAME_TYPE_DECL, x, x) #undef FRAME_TYPE_DECL }; class same_frame : public stack_map_frame { private: static int frame_type_to_offset_delta(u1 frame_type) { return frame_type + 1; } static u1 offset_delta_to_frame_type(int offset_delta) { return (u1)(offset_delta - 1); } public: static bool is_frame_type(u1 tag) { return tag < 64; } static same_frame* at(address addr) { assert(is_frame_type(*addr), "Wrong frame id"); return (same_frame*)addr; } static same_frame* create_at(address addr, int offset_delta) { same_frame* sm = (same_frame*)addr; sm->set_offset_delta(offset_delta); return sm; } static size_t calculate_size() { return sizeof(u1); } size_t size() const { return calculate_size(); } int offset_delta() const { return frame_type_to_offset_delta(frame_type()); } void set_offset_delta(int offset_delta) { assert(offset_delta <= 64, "Offset too large for same_frame"); set_frame_type(offset_delta_to_frame_type(offset_delta)); } int number_of_types() const { return 0; } verification_type_info* types() const { return NULL; } bool is_valid_offset(int offset_delta) const { return is_frame_type(offset_delta_to_frame_type(offset_delta)); } bool verify_subtype(address start, address end) const { return true; } void print_on(outputStream* st, int current_offset = -1) const { st->print("same_frame(@%d)", offset_delta() + current_offset); } }; class same_frame_extended : public stack_map_frame { private: enum { _frame_id = 251 }; address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); } public: static bool is_frame_type(u1 tag) { return tag == _frame_id; } static same_frame_extended* at(address addr) { assert(is_frame_type(*addr), "Wrong frame type"); return (same_frame_extended*)addr; } static same_frame_extended* create_at(address addr, u2 offset_delta) { same_frame_extended* sm = (same_frame_extended*)addr; sm->set_frame_type(_frame_id); sm->set_offset_delta(offset_delta); return sm; } static size_t calculate_size() { return sizeof(u1) + sizeof(u2); } size_t size() const { return calculate_size(); } int offset_delta() const { return Bytes::get_Java_u2(offset_delta_addr()) + 1; } void set_offset_delta(int offset_delta) { Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1); } int number_of_types() const { return 0; } verification_type_info* types() const { return NULL; } bool is_valid_offset(int offset) const { return true; } bool verify_subtype(address start, address end) const { return frame_type_addr() + size() <= end; } void print_on(outputStream* st, int current_offset = -1) const { st->print("same_frame_extended(@%d)", offset_delta() + current_offset); } }; class same_locals_1_stack_item_frame : public stack_map_frame { private: address type_addr() const { return frame_type_addr() + sizeof(u1); } static int frame_type_to_offset_delta(u1 frame_type) { return frame_type - 63; } static u1 offset_delta_to_frame_type(int offset_delta) { return (u1)(offset_delta + 63); } public: static bool is_frame_type(u1 tag) { return tag >= 64 && tag < 128; } static same_locals_1_stack_item_frame* at(address addr) { assert(is_frame_type(*addr), "Wrong frame id"); return (same_locals_1_stack_item_frame*)addr; } static same_locals_1_stack_item_frame* create_at( address addr, int offset_delta, verification_type_info* vti) { same_locals_1_stack_item_frame* sm = (same_locals_1_stack_item_frame*)addr; sm->set_offset_delta(offset_delta); if (vti != NULL) { sm->set_type(vti); } return sm; } static size_t calculate_size(verification_type_info* vti) { return sizeof(u1) + vti->size(); } static size_t max_size() { return sizeof(u1) + verification_type_info::max_size(); } size_t size() const { return calculate_size(types()); } int offset_delta() const { return frame_type_to_offset_delta(frame_type()); } void set_offset_delta(int offset_delta) { assert(offset_delta > 0 && offset_delta <= 64, "Offset too large for this frame type"); set_frame_type(offset_delta_to_frame_type(offset_delta)); } void set_type(verification_type_info* vti) { verification_type_info* cur = types(); cur->copy_from(vti); } int number_of_types() const { return 1; } verification_type_info* types() const { return verification_type_info::at(type_addr()); } bool is_valid_offset(int offset_delta) const { return is_frame_type(offset_delta_to_frame_type(offset_delta)); } bool verify_subtype(address start, address end) const { return types()->verify(start, end); } void print_on(outputStream* st, int current_offset = -1) const { st->print("same_locals_1_stack_item_frame(@%d,", offset_delta() + current_offset); types()->print_on(st); st->print(")"); } }; class same_locals_1_stack_item_extended : public stack_map_frame { private: address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); } address type_addr() const { return offset_delta_addr() + sizeof(u2); } enum { _frame_id = 247 }; public: static bool is_frame_type(u1 tag) { return tag == _frame_id; } static same_locals_1_stack_item_extended* at(address addr) { assert(is_frame_type(*addr), "Wrong frame id"); return (same_locals_1_stack_item_extended*)addr; } static same_locals_1_stack_item_extended* create_at( address addr, int offset_delta, verification_type_info* vti) { same_locals_1_stack_item_extended* sm = (same_locals_1_stack_item_extended*)addr; sm->set_frame_type(_frame_id); sm->set_offset_delta(offset_delta); if (vti != NULL) { sm->set_type(vti); } return sm; } static size_t calculate_size(verification_type_info* vti) { return sizeof(u1) + sizeof(u2) + vti->size(); } size_t size() const { return calculate_size(types()); } int offset_delta() const { return Bytes::get_Java_u2(offset_delta_addr()) + 1; } void set_offset_delta(int offset_delta) { Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1); } void set_type(verification_type_info* vti) { verification_type_info* cur = types(); cur->copy_from(vti); } int number_of_types() const { return 1; } verification_type_info* types() const { return verification_type_info::at(type_addr()); } bool is_valid_offset(int offset) { return true; } bool verify_subtype(address start, address end) const { return type_addr() < end && types()->verify(start, end); } void print_on(outputStream* st, int current_offset = -1) const { st->print("same_locals_1_stack_item_extended(@%d,", offset_delta() + current_offset); types()->print_on(st); st->print(")"); } }; class chop_frame : public stack_map_frame { private: address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); } static int frame_type_to_chops(u1 frame_type) { int chop = 251 - frame_type; return chop; } static u1 chops_to_frame_type(int chop) { return 251 - chop; } public: static bool is_frame_type(u1 tag) { return frame_type_to_chops(tag) > 0 && frame_type_to_chops(tag) < 4; } static chop_frame* at(address addr) { assert(is_frame_type(*addr), "Wrong frame id"); return (chop_frame*)addr; } static chop_frame* create_at(address addr, int offset_delta, int chops) { chop_frame* sm = (chop_frame*)addr; sm->set_chops(chops); sm->set_offset_delta(offset_delta); return sm; } static size_t calculate_size() { return sizeof(u1) + sizeof(u2); } size_t size() const { return calculate_size(); } int offset_delta() const { return Bytes::get_Java_u2(offset_delta_addr()) + 1; } void set_offset_delta(int offset_delta) { Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1); } int chops() const { int chops = frame_type_to_chops(frame_type()); assert(chops > 0 && chops < 4, "Invalid number of chops in frame"); return chops; } void set_chops(int chops) { assert(chops > 0 && chops <= 3, "Bad number of chops"); set_frame_type(chops_to_frame_type(chops)); } int number_of_types() const { return 0; } verification_type_info* types() const { return NULL; } bool is_valid_offset(int offset) { return true; } bool verify_subtype(address start, address end) const { return frame_type_addr() + size() <= end; } void print_on(outputStream* st, int current_offset = -1) const { st->print("chop_frame(@%d,%d)", offset_delta() + current_offset, chops()); } }; class append_frame : public stack_map_frame { private: address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); } address types_addr() const { return offset_delta_addr() + sizeof(u2); } static int frame_type_to_appends(u1 frame_type) { int append = frame_type - 251; return append; } static u1 appends_to_frame_type(int appends) { assert(appends > 0 && appends < 4, "Invalid append amount"); return 251 + appends; } public: static bool is_frame_type(u1 tag) { return frame_type_to_appends(tag) > 0 && frame_type_to_appends(tag) < 4; } static append_frame* at(address addr) { assert(is_frame_type(*addr), "Wrong frame id"); return (append_frame*)addr; } static append_frame* create_at( address addr, int offset_delta, int appends, verification_type_info* types) { append_frame* sm = (append_frame*)addr; sm->set_appends(appends); sm->set_offset_delta(offset_delta); if (types != NULL) { verification_type_info* cur = sm->types(); for (int i = 0; i < appends; ++i) { cur->copy_from(types); cur = cur->next(); types = types->next(); } } return sm; } static size_t calculate_size(int appends, verification_type_info* types) { size_t sz = sizeof(u1) + sizeof(u2); for (int i = 0; i < appends; ++i) { sz += types->size(); types = types->next(); } return sz; } static size_t max_size() { return sizeof(u1) + sizeof(u2) + 3 * verification_type_info::max_size(); } size_t size() const { return calculate_size(number_of_types(), types()); } int offset_delta() const { return Bytes::get_Java_u2(offset_delta_addr()) + 1; } void set_offset_delta(int offset_delta) { Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1); } void set_appends(int appends) { assert(appends > 0 && appends < 4, "Bad number of appends"); set_frame_type(appends_to_frame_type(appends)); } int number_of_types() const { int appends = frame_type_to_appends(frame_type()); assert(appends > 0 && appends < 4, "Invalid number of appends in frame"); return appends; } verification_type_info* types() const { return verification_type_info::at(types_addr()); } bool is_valid_offset(int offset) const { return true; } bool verify_subtype(address start, address end) const { verification_type_info* vti = types(); if ((address)vti < end && vti->verify(start, end)) { int nof = number_of_types(); vti = vti->next(); if (nof < 2 || vti->verify(start, end)) { vti = vti->next(); if (nof < 3 || vti->verify(start, end)) { return true; } } } return false; } void print_on(outputStream* st, int current_offset = -1) const { st->print("append_frame(@%d,", offset_delta() + current_offset); verification_type_info* vti = types(); for (int i = 0; i < number_of_types(); ++i) { vti->print_on(st); if (i != number_of_types() - 1) { st->print(","); } vti = vti->next(); } st->print(")"); } }; class full_frame : public stack_map_frame { private: address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); } address num_locals_addr() const { return offset_delta_addr() + sizeof(u2); } address locals_addr() const { return num_locals_addr() + sizeof(u2); } address stack_slots_addr(address end_of_locals) const { return end_of_locals; } address stack_addr(address end_of_locals) const { return stack_slots_addr(end_of_locals) + sizeof(u2); } enum { _frame_id = 255 }; public: static bool is_frame_type(u1 tag) { return tag == _frame_id; } static full_frame* at(address addr) { assert(is_frame_type(*addr), "Wrong frame id"); return (full_frame*)addr; } static full_frame* create_at( address addr, int offset_delta, int num_locals, verification_type_info* locals, int stack_slots, verification_type_info* stack) { full_frame* sm = (full_frame*)addr; sm->set_frame_type(_frame_id); sm->set_offset_delta(offset_delta); sm->set_num_locals(num_locals); if (locals != NULL) { verification_type_info* cur = sm->locals(); for (int i = 0; i < num_locals; ++i) { cur->copy_from(locals); cur = cur->next(); locals = locals->next(); } address end_of_locals = (address)cur; sm->set_stack_slots(end_of_locals, stack_slots); cur = sm->stack(end_of_locals); for (int i = 0; i < stack_slots; ++i) { cur->copy_from(stack); cur = cur->next(); stack = stack->next(); } } return sm; } static size_t calculate_size( int num_locals, verification_type_info* locals, int stack_slots, verification_type_info* stack) { size_t sz = sizeof(u1) + sizeof(u2) + sizeof(u2) + sizeof(u2); verification_type_info* vti = locals; for (int i = 0; i < num_locals; ++i) { sz += vti->size(); vti = vti->next(); } vti = stack; for (int i = 0; i < stack_slots; ++i) { sz += vti->size(); vti = vti->next(); } return sz; } static size_t max_size(int locals, int stack) { return sizeof(u1) + 3 * sizeof(u2) + (locals + stack) * verification_type_info::max_size(); } size_t size() const { address eol = end_of_locals(); return calculate_size(num_locals(), locals(), stack_slots(eol), stack(eol)); } int offset_delta() const { return Bytes::get_Java_u2(offset_delta_addr()) + 1; } int num_locals() const { return Bytes::get_Java_u2(num_locals_addr()); } verification_type_info* locals() const { return verification_type_info::at(locals_addr()); } address end_of_locals() const { verification_type_info* vti = locals(); for (int i = 0; i < num_locals(); ++i) { vti = vti->next(); } return (address)vti; } int stack_slots(address end_of_locals) const { return Bytes::get_Java_u2(stack_slots_addr(end_of_locals)); } verification_type_info* stack(address end_of_locals) const { return verification_type_info::at(stack_addr(end_of_locals)); } void set_offset_delta(int offset_delta) { Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1); } void set_num_locals(int num_locals) { Bytes::put_Java_u2(num_locals_addr(), num_locals); } void set_stack_slots(address end_of_locals, int stack_slots) { Bytes::put_Java_u2(stack_slots_addr(end_of_locals), stack_slots); } // These return only the locals. Extra processing is required for stack // types of full frames. int number_of_types() const { return num_locals(); } verification_type_info* types() const { return locals(); } bool is_valid_offset(int offset) { return true; } bool verify_subtype(address start, address end) const { verification_type_info* vti = types(); if ((address)vti >= end) { return false; } int count = number_of_types(); for (int i = 0; i < count; ++i) { if (!vti->verify(start, end)) { return false; } vti = vti->next(); } address eol = (address)vti; if (eol + sizeof(u2) > end) { return false; } count = stack_slots(eol); vti = stack(eol); for (int i = 0; i < stack_slots(eol); ++i) { if (!vti->verify(start, end)) { return false; } vti = vti->next(); } return true; } void print_on(outputStream* st, int current_offset = -1) const { st->print("full_frame(@%d,{", offset_delta() + current_offset); verification_type_info* vti = locals(); for (int i = 0; i < num_locals(); ++i) { vti->print_on(st); if (i != num_locals() - 1) { st->print(","); } vti = vti->next(); } st->print("},{"); address end_of_locals = (address)vti; vti = stack(end_of_locals); int ss = stack_slots(end_of_locals); for (int i = 0; i < ss; ++i) { vti->print_on(st); if (i != ss - 1) { st->print(","); } vti = vti->next(); } st->print("})"); } }; #define VIRTUAL_DISPATCH(stack_frame_type, func_name, args) \ stack_frame_type* item_##stack_frame_type = as_##stack_frame_type(); \ if (item_##stack_frame_type != NULL) { \ return item_##stack_frame_type->func_name args; \ } #define VOID_VIRTUAL_DISPATCH(stack_frame_type, func_name, args) \ stack_frame_type* item_##stack_frame_type = as_##stack_frame_type(); \ if (item_##stack_frame_type != NULL) { \ item_##stack_frame_type->func_name args; \ return; \ } size_t stack_map_frame::size() const { FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, size, ()); return 0; } int stack_map_frame::offset_delta() const { FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, offset_delta, ()); return 0; } void stack_map_frame::set_offset_delta(int offset_delta) { FOR_EACH_STACKMAP_FRAME_TYPE( VOID_VIRTUAL_DISPATCH, set_offset_delta, (offset_delta)); } int stack_map_frame::number_of_types() const { FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, number_of_types, ()); return 0; } verification_type_info* stack_map_frame::types() const { FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, types, ()); return NULL; } bool stack_map_frame::is_valid_offset(int offset) const { FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, is_valid_offset, (offset)); return true; } bool stack_map_frame::verify(address start, address end) const { if (frame_type_addr() >= start && frame_type_addr() < end) { FOR_EACH_STACKMAP_FRAME_TYPE( VIRTUAL_DISPATCH, verify_subtype, (start, end)); } return false; } void stack_map_frame::print_on(outputStream* st, int offs = -1) const { FOR_EACH_STACKMAP_FRAME_TYPE(VOID_VIRTUAL_DISPATCH, print_on, (st, offs)); } #undef VIRTUAL_DISPATCH #undef VOID_VIRTUAL_DISPATCH #define AS_SUBTYPE_DEF(stack_frame_type, arg1, arg2) \ stack_frame_type* stack_map_frame::as_##stack_frame_type() const { \ if (stack_frame_type::is_frame_type(frame_type())) { \ return (stack_frame_type*)this; \ } else { \ return NULL; \ } \ } FOR_EACH_STACKMAP_FRAME_TYPE(AS_SUBTYPE_DEF, x, x) #undef AS_SUBTYPE_DEF class stack_map_table { private: address number_of_entries_addr() const { return (address)this; } address entries_addr() const { return number_of_entries_addr() + sizeof(u2); } protected: // No constructors - should be 'private', but GCC issues a warning if it is stack_map_table() {} stack_map_table(const stack_map_table&) {} public: static stack_map_table* at(address addr) { return (stack_map_table*)addr; } u2 number_of_entries() const { return Bytes::get_Java_u2(number_of_entries_addr()); } stack_map_frame* entries() const { return stack_map_frame::at(entries_addr()); } void set_number_of_entries(u2 num) { Bytes::put_Java_u2(number_of_entries_addr(), num); } }; class stack_map_table_attribute { private: address name_index_addr() const { return (address)this; } address attribute_length_addr() const { return name_index_addr() + sizeof(u2); } address stack_map_table_addr() const { return attribute_length_addr() + sizeof(u4); } protected: // No constructors - should be 'private', but GCC issues a warning if it is stack_map_table_attribute() {} stack_map_table_attribute(const stack_map_table_attribute&) {} public: static stack_map_table_attribute* at(address addr) { return (stack_map_table_attribute*)addr; } u2 name_index() const { return Bytes::get_Java_u2(name_index_addr()); } u4 attribute_length() const { return Bytes::get_Java_u4(attribute_length_addr()); } stack_map_table* table() const { return stack_map_table::at(stack_map_table_addr()); } void set_name_index(u2 idx) { Bytes::put_Java_u2(name_index_addr(), idx); } void set_attribute_length(u4 len) { Bytes::put_Java_u4(attribute_length_addr(), len); } }; #undef FOR_EACH_STACKMAP_FRAME_TYPE #endif // SHARE_VM_CLASSFILE_STACKMAPTABLEFORMAT_HPP