1 /* 2 * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_OOPS_RESOLVEDFIELDENTRY_HPP 26 #define SHARE_OOPS_RESOLVEDFIELDENTRY_HPP 27 28 #include "interpreter/bytecodes.hpp" 29 #include "oops/instanceKlass.hpp" 30 #include "runtime/atomic.hpp" 31 #include "utilities/checkedCast.hpp" 32 #include "utilities/sizes.hpp" 33 34 // ResolvedFieldEntry contains the resolution information for field related bytecodes like 35 // like getfield, putfield, getstatic, and putstatic. A member of this class can be initialized 36 // with the constant pool index associated with the bytecode before any resolution is done, where 37 // "resolution" refers to populating the getcode and putcode fields and other relevant information. 38 // The field's type (TOS), offset, holder klass, and index within that class can all be acquired 39 // together and are used to populate this structure. These entries are contained 40 // within the ConstantPoolCache and are accessed with indices added to the invokedynamic bytecode after 41 // rewriting. 42 43 // Field bytecodes start with a constant pool index as their operate, which is then rewritten to 44 // a "field index", which is an index into the array of ResolvedFieldEntry. 45 46 //class InstanceKlass; 47 class ResolvedFieldEntry { 48 friend class VMStructs; 49 50 InstanceKlass* _field_holder; // Field holder klass 51 int _field_offset; // Field offset in bytes 52 u2 _field_index; // Index into field information in holder InstanceKlass 53 u2 _cpool_index; // Constant pool index 54 u1 _tos_state; // TOS state 55 u1 _flags; // Flags: [0000|00|is_final|is_volatile] 56 u1 _get_code, _put_code; // Get and Put bytecodes of the field 57 58 public: 59 ResolvedFieldEntry(u2 cpi) : 60 _field_holder(nullptr), 61 _field_offset(0), 62 _field_index(0), 63 _cpool_index(cpi), 64 _tos_state(0), 65 _flags(0), 66 _get_code(0), 67 _put_code(0) {} 68 ResolvedFieldEntry() : 69 ResolvedFieldEntry(0) {} 70 71 // Bit shift to get flags 72 // Note: Only two flags exists at the moment but more could be added 73 enum { 74 is_volatile_shift = 0, 75 is_final_shift = 1, // unused 76 }; 77 78 // Getters 79 InstanceKlass* field_holder() const { return _field_holder; } 80 int field_offset() const { return _field_offset; } 81 u2 field_index() const { return _field_index; } 82 u2 constant_pool_index() const { return _cpool_index; } 83 u1 tos_state() const { return _tos_state; } 84 u1 get_code() const { return Atomic::load_acquire(&_get_code); } 85 u1 put_code() const { return Atomic::load_acquire(&_put_code); } 86 bool is_final() const { return (_flags & (1 << is_final_shift)) != 0; } 87 bool is_volatile () const { return (_flags & (1 << is_volatile_shift)) != 0; } 88 bool is_resolved(Bytecodes::Code code) const { 89 switch(code) { 90 case Bytecodes::_getstatic: 91 case Bytecodes::_getfield: 92 return (get_code() == code); 93 case Bytecodes::_putstatic: 94 case Bytecodes::_putfield: 95 return (put_code() == code); 96 default: 97 ShouldNotReachHere(); 98 return false; 99 } 100 } 101 102 // Printing 103 void print_on(outputStream* st) const; 104 105 void set_flags(bool is_final_flag, bool is_volatile_flag) { 106 int new_flags = (is_final_flag << is_final_shift) | static_cast<int>(is_volatile_flag); 107 _flags = checked_cast<u1>(new_flags); 108 assert(is_final() == is_final_flag, "Must be"); 109 assert(is_volatile() == is_volatile_flag, "Must be"); 110 } 111 112 inline void set_bytecode(u1* code, u1 new_code) { 113 #ifdef ASSERT 114 // Read once. 115 volatile Bytecodes::Code c = (Bytecodes::Code)*code; 116 assert(c == 0 || c == new_code || new_code == 0, "update must be consistent"); 117 #endif 118 Atomic::release_store(code, new_code); 119 } 120 121 // Populate the strucutre with resolution information 122 void fill_in(InstanceKlass* klass, int offset, u2 index, u1 tos_state, u1 b1, u1 b2) { 123 _field_holder = klass; 124 _field_offset = offset; 125 _field_index = index; 126 _tos_state = tos_state; 127 128 // These must be set after the other fields 129 set_bytecode(&_get_code, b1); 130 set_bytecode(&_put_code, b2); 131 } 132 133 // CDS 134 void remove_unshareable_info(); 135 136 // Offsets 137 static ByteSize field_holder_offset() { return byte_offset_of(ResolvedFieldEntry, _field_holder); } 138 static ByteSize field_offset_offset() { return byte_offset_of(ResolvedFieldEntry, _field_offset); } 139 static ByteSize field_index_offset() { return byte_offset_of(ResolvedFieldEntry, _field_index); } 140 static ByteSize get_code_offset() { return byte_offset_of(ResolvedFieldEntry, _get_code); } 141 static ByteSize put_code_offset() { return byte_offset_of(ResolvedFieldEntry, _put_code); } 142 static ByteSize type_offset() { return byte_offset_of(ResolvedFieldEntry, _tos_state); } 143 static ByteSize flags_offset() { return byte_offset_of(ResolvedFieldEntry, _flags); } 144 145 }; 146 147 #endif //SHARE_OOPS_RESOLVEDFIELDENTRY_HPP