/* * Copyright (c) 2023, 2024, 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_OOPS_RESOLVEDMETHODENTRY_HPP #define SHARE_OOPS_RESOLVEDMETHODENTRY_HPP #include "interpreter/bytecodes.hpp" #include "runtime/atomic.hpp" #include "utilities/sizes.hpp" // ResolvedMethodEntry contains the resolution information for the invoke bytecodes // invokestatic, invokespecial, invokeinterface, invokevirtual, and invokehandle but // NOT invokedynamic (see resolvedIndyEntry.hpp). A member of this class can be initialized // with the constant pool index associated with the bytecode before any resolution is done, // where "resolution" refers to populating the bytecode1 and bytecode2 fields and other // relevant information. These entries are contained within the ConstantPoolCache and are // accessed with indices added to the bytecode after rewriting. // Invoke bytecodes start with a constant pool index as their operand, which is then // rewritten to a "method index", which is an index into the array of ResolvedMethodEntry. // This structure has fields for every type of invoke bytecode but each entry may only // use some of the fields. All entries have a TOS state, number of parameters, flags, // and a constant pool index. // Types of invokes // invokestatic // invokespecial // Method* // invokehandle // Method* // resolved references index // invokevirtual // Method* (if vfinal is true) // vtable/itable index // invokeinterface // Klass* // Method* // Note: invokevirtual & invokespecial bytecodes can share the same constant // pool entry and thus the same resolved method entry. // The is_vfinal flag indicates method pointer for a final method or an index. class InstanceKlass; class ResolvedMethodEntry { friend class VMStructs; Method* _method; // Method for non virtual calls, adapter method for invokevirtual, final method for virtual union { // These fields are mutually exclusive and are only used by some invoke codes InstanceKlass* _interface_klass; // for interface and static u2 _resolved_references_index; // Index of resolved references array that holds the appendix oop for invokehandle u2 _table_index; // vtable/itable index for virtual and interface calls } _entry_specific; u2 _cpool_index; // Constant pool index u2 _number_of_parameters; // Number of arguments for method u1 _tos_state; // TOS state u1 _flags; // Flags: [00|has_resolved_ref_index|has_local_signature|has_appendix|forced_virtual|final|virtual_final] u1 _bytecode1, _bytecode2; // Resolved invoke codes #ifdef ASSERT bool _has_interface_klass; bool _has_table_index; #endif void copy_from(const ResolvedMethodEntry& other) { _method = other._method; _entry_specific = other._entry_specific; _cpool_index = other._cpool_index; _number_of_parameters = other._number_of_parameters; _tos_state = other._tos_state; _flags = other._flags; _bytecode1 = other._bytecode1; _bytecode2 = other._bytecode2; #ifdef ASSERT _has_interface_klass = other._has_interface_klass; _has_table_index = other._has_table_index; #endif } // Constructors public: ResolvedMethodEntry(u2 cpi) : _method(nullptr), _cpool_index(cpi), _number_of_parameters(0), _tos_state(0), _flags(0), _bytecode1(0), _bytecode2(0) { _entry_specific._interface_klass = nullptr; DEBUG_ONLY(_has_interface_klass = false;) DEBUG_ONLY(_has_table_index = false;) } ResolvedMethodEntry() : ResolvedMethodEntry(0) {} ResolvedMethodEntry(const ResolvedMethodEntry& other) { copy_from(other); } ResolvedMethodEntry& operator=(const ResolvedMethodEntry& other) { copy_from(other); return *this; } // Bit shift to get flags enum { is_vfinal_shift = 0, is_final_shift = 1, is_forced_virtual_shift = 2, has_appendix_shift = 3, has_local_signature_shift = 4, has_resolved_ref_shift = 5 }; // Flags bool is_vfinal() const { return (_flags & (1 << is_vfinal_shift)) != 0; } bool is_final() const { return (_flags & (1 << is_final_shift)) != 0; } bool is_forced_virtual() const { return (_flags & (1 << is_forced_virtual_shift)) != 0; } bool has_appendix() const { return (_flags & (1 << has_appendix_shift)) != 0; } bool has_local_signature() const { return (_flags & (1 << has_local_signature_shift)) != 0; } bool has_resolved_references_index() const { return (_flags & (1 << has_resolved_ref_shift)) != 0; } // Getters Method* method() const { return Atomic::load_acquire(&_method); } InstanceKlass* interface_klass() const { assert(_bytecode1 == Bytecodes::_invokeinterface, "Only invokeinterface has a klass %d", _bytecode1); assert(_has_interface_klass, "sanity"); return _entry_specific._interface_klass; } u2 resolved_references_index() const { // This index may be read before resolution completes assert(has_resolved_references_index(), "sanity"); return _entry_specific._resolved_references_index; } u2 table_index() const { assert(_bytecode2 == Bytecodes::_invokevirtual, "Only invokevirtual has a vtable/itable index %d", _bytecode2); assert(_has_table_index, "sanity"); return _entry_specific._table_index; } u2 constant_pool_index() const { return _cpool_index; } u1 tos_state() const { return _tos_state; } u2 number_of_parameters() const { return _number_of_parameters; } u1 bytecode1() const { return Atomic::load_acquire(&_bytecode1); } u1 bytecode2() const { return Atomic::load_acquire(&_bytecode2); } bool is_resolved(Bytecodes::Code code) const { switch(code) { case Bytecodes::_invokeinterface: case Bytecodes::_invokehandle: case Bytecodes::_invokespecial: case Bytecodes::_invokestatic: return (bytecode1() == code); case Bytecodes::_invokevirtual: return (bytecode2() == code); default: ShouldNotReachHere(); return false; } } void adjust_method_entry(Method* new_method) { // this is done during the redefinition safepoint _method = new_method; } bool check_no_old_or_obsolete_entry(); // Printing void print_on(outputStream* st) const; // Setters void set_flags(u1 flags) { _flags |= flags; } inline void set_bytecode(u1* code, u1 new_code) { #ifdef ASSERT // Read once. volatile Bytecodes::Code c = (Bytecodes::Code)*code; assert(c == 0 || c == new_code || new_code == 0, "update must be consistent old: %d, new: %d", c, new_code); #endif Atomic::release_store(code, new_code); } void set_bytecode1(u1 b1) { set_bytecode(&_bytecode1, b1); } void set_bytecode2(u1 b2) { set_bytecode(&_bytecode2, b2); } void set_method(Method* m) { Atomic::release_store(&_method, m); } void set_klass(InstanceKlass* klass) { assert(!has_resolved_references_index() && !_has_table_index, "Mutually exclusive fields %d %d %d", has_resolved_references_index(), _has_interface_klass, _has_table_index); DEBUG_ONLY(_has_interface_klass = true;) _entry_specific._interface_klass = klass; } void set_resolved_references_index(u2 ref_index) { assert(!_has_interface_klass && !_has_table_index, "Mutually exclusive fields %d %d %d", has_resolved_references_index(), _has_interface_klass, _has_table_index); set_flags(1 << has_resolved_ref_shift); _entry_specific._resolved_references_index = ref_index; } void set_table_index(u2 table_index) { assert(!has_resolved_references_index() && !_has_interface_klass, "Mutually exclusive fields %d %d %d", has_resolved_references_index(), _has_interface_klass, _has_table_index); DEBUG_ONLY(_has_table_index = true;) _entry_specific._table_index = table_index; } void set_num_parameters(u2 num_params) { _number_of_parameters = num_params; } void fill_in(u1 tos_state, u2 num_params) { _tos_state = tos_state; _number_of_parameters = num_params; } void reset_entry(); // CDS #if INCLUDE_CDS void remove_unshareable_info(); void mark_and_relocate(ConstantPool* src_cp); #endif // Offsets static ByteSize klass_offset() { return byte_offset_of(ResolvedMethodEntry, _entry_specific._interface_klass); } static ByteSize method_offset() { return byte_offset_of(ResolvedMethodEntry, _method); } static ByteSize resolved_references_index_offset() { return byte_offset_of(ResolvedMethodEntry, _entry_specific._resolved_references_index); } static ByteSize table_index_offset() { return byte_offset_of(ResolvedMethodEntry, _entry_specific._table_index); } static ByteSize num_parameters_offset() { return byte_offset_of(ResolvedMethodEntry, _number_of_parameters); } static ByteSize type_offset() { return byte_offset_of(ResolvedMethodEntry, _tos_state); } static ByteSize flags_offset() { return byte_offset_of(ResolvedMethodEntry, _flags); } static ByteSize bytecode1_offset() { return byte_offset_of(ResolvedMethodEntry, _bytecode1); } static ByteSize bytecode2_offset() { return byte_offset_of(ResolvedMethodEntry, _bytecode2); } }; #endif //SHARE_OOPS_RESOLVEDMETHODENTRY_HPP