1 /*
  2  * Copyright (c) 1997, 2025, 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_CONSTANTPOOL_HPP
 26 #define SHARE_OOPS_CONSTANTPOOL_HPP
 27 
 28 #include "memory/allocation.hpp"
 29 #include "oops/arrayOop.hpp"
 30 #include "oops/cpCache.hpp"
 31 #include "oops/objArrayOop.hpp"
 32 #include "oops/oopHandle.hpp"
 33 #include "oops/symbol.hpp"
 34 #include "oops/typeArrayOop.hpp"
 35 #include "runtime/handles.hpp"
 36 #include "runtime/javaThread.hpp"
 37 #include "utilities/align.hpp"
 38 #include "utilities/bytes.hpp"
 39 #include "utilities/constantTag.hpp"
 40 #include "utilities/macros.hpp"
 41 #include "utilities/resourceHash.hpp"
 42 
 43 // A ConstantPool is an array containing class constants as described in the
 44 // class file.
 45 //
 46 // Most of the constant pool entries are written during class parsing, which
 47 // is safe.  For klass types, the constant pool entry is
 48 // modified when the entry is resolved.  If a klass constant pool
 49 // entry is read without a lock, only the resolved state guarantees that
 50 // the entry in the constant pool is a klass object and not a Symbol*.
 51 
 52 // This represents a JVM_CONSTANT_Class, JVM_CONSTANT_UnresolvedClass, or
 53 // JVM_CONSTANT_UnresolvedClassInError slot in the constant pool.
 54 class CPKlassSlot {
 55   // cp->symbol_at(_name_index) gives the name of the class.
 56   int _name_index;
 57 
 58   // cp->_resolved_klasses->at(_resolved_klass_index) gives the Klass* for the class.
 59   int _resolved_klass_index;
 60 public:
 61   enum {
 62     // This is used during constant pool merging where the resolved klass index is
 63     // not yet known, and will be computed at a later stage (during a call to
 64     // initialize_unresolved_klasses()).
 65     _temp_resolved_klass_index = 0xffff
 66   };
 67   CPKlassSlot(int n, int rk) {
 68     _name_index = n;
 69     _resolved_klass_index = rk;
 70   }
 71   int name_index() const {
 72     return _name_index;
 73   }
 74   int resolved_klass_index() const {
 75     assert(_resolved_klass_index != _temp_resolved_klass_index, "constant pool merging was incomplete");
 76     return _resolved_klass_index;
 77   }
 78 };
 79 
 80 class ConstantPool : public Metadata {
 81   friend class VMStructs;
 82   friend class JVMCIVMStructs;
 83   friend class BytecodeInterpreter;  // Directly extracts a klass in the pool for fast instanceof/checkcast
 84   friend class Universe;             // For null constructor
 85   friend class AOTConstantPoolResolver;
 86  private:
 87   // If you add a new field that points to any metaspace object, you
 88   // must add this field to ConstantPool::metaspace_pointers_do().
 89   Array<u1>*           _tags;        // the tag array describing the constant pool's contents
 90   ConstantPoolCache*   _cache;       // the cache holding interpreter runtime information
 91   InstanceKlass*       _pool_holder; // the corresponding class
 92   Array<u2>*           _operands;    // for variable-sized (InvokeDynamic) nodes, usually empty
 93 
 94   // Consider using an array of compressed klass pointers to
 95   // save space on 64-bit platforms.
 96   Array<Klass*>*       _resolved_klasses;
 97 
 98   u2              _major_version;        // major version number of class file
 99   u2              _minor_version;        // minor version number of class file
100 
101   // Constant pool index to the utf8 entry of the Generic signature,
102   // or 0 if none.
103   u2              _generic_signature_index;
104   // Constant pool index to the utf8 entry for the name of source file
105   // containing this klass, 0 if not specified.
106   u2              _source_file_name_index;
107 
108   enum {
109     _has_preresolution    = 1,       // Flags
110     _on_stack             = 2,
111     _is_shared            = 4,
112     _has_dynamic_constant = 8,
113     _is_for_method_handle_intrinsic = 16
114   };
115 
116   u2              _flags;  // old fashioned bit twiddling
117 
118   int             _length; // number of elements in the array
119 
120   union {
121     // set for CDS to restore resolved references
122     int                _resolved_reference_length;
123     // keeps version number for redefined classes (used in backtrace)
124     int                _version;
125   } _saved;
126 
127   void set_tags(Array<u1>* tags)                 { _tags = tags; }
128   void tag_at_put(int cp_index, jbyte t)         { tags()->at_put(cp_index, t); }
129   void release_tag_at_put(int cp_index, jbyte t) { tags()->release_at_put(cp_index, t); }
130 
131   u1* tag_addr_at(int cp_index) const            { return tags()->adr_at(cp_index); }
132 
133   void set_operands(Array<u2>* operands)       { _operands = operands; }
134 
135   u2 flags() const                             { return _flags; }
136   void set_flags(u2 f)                         { _flags = f; }
137 
138  private:
139   intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(ConstantPool)); }
140 
141   intptr_t* obj_at_addr(int cp_index) const {
142     assert(is_within_bounds(cp_index), "index out of bounds");
143     return (intptr_t*) &base()[cp_index];
144   }
145 
146   jint* int_at_addr(int cp_index) const {
147     assert(is_within_bounds(cp_index), "index out of bounds");
148     return (jint*) &base()[cp_index];
149   }
150 
151   jlong* long_at_addr(int cp_index) const {
152     assert(is_within_bounds(cp_index), "index out of bounds");
153     return (jlong*) &base()[cp_index];
154   }
155 
156   jfloat* float_at_addr(int cp_index) const {
157     assert(is_within_bounds(cp_index), "index out of bounds");
158     return (jfloat*) &base()[cp_index];
159   }
160 
161   jdouble* double_at_addr(int cp_index) const {
162     assert(is_within_bounds(cp_index), "index out of bounds");
163     return (jdouble*) &base()[cp_index];
164   }
165   static void check_and_add_dumped_interned_string(oop obj);
166 
167   ConstantPool(Array<u1>* tags);
168   ConstantPool();
169  public:
170   static ConstantPool* allocate(ClassLoaderData* loader_data, int length, TRAPS);
171 
172   virtual bool is_constantPool() const      { return true; }
173 
174   Array<u1>* tags() const                   { return _tags; }
175   Array<u2>* operands() const               { return _operands; }
176 
177   bool has_preresolution() const            { return (_flags & _has_preresolution) != 0; }
178   void set_has_preresolution() {
179     assert(!is_shared(), "should never be called on shared ConstantPools");
180     _flags |= _has_preresolution;
181   }
182 
183   // minor and major version numbers of class file
184   u2 major_version() const                 { return _major_version; }
185   void set_major_version(u2 major_version) { _major_version = major_version; }
186   u2 minor_version() const                 { return _minor_version; }
187   void set_minor_version(u2 minor_version) { _minor_version = minor_version; }
188 
189   // generics support
190   Symbol* generic_signature() const {
191     return (_generic_signature_index == 0) ?
192       nullptr : symbol_at(_generic_signature_index);
193   }
194   u2 generic_signature_index() const                   { return _generic_signature_index; }
195   void set_generic_signature_index(u2 sig_index)       { _generic_signature_index = sig_index; }
196 
197   // source file name
198   Symbol* source_file_name() const {
199     return (_source_file_name_index == 0) ?
200       nullptr : symbol_at(_source_file_name_index);
201   }
202   u2 source_file_name_index() const                    { return _source_file_name_index; }
203   void set_source_file_name_index(u2 sourcefile_index) { _source_file_name_index = sourcefile_index; }
204 
205   void copy_fields(const ConstantPool* orig);
206 
207   // Redefine classes support.  If a method referring to this constant pool
208   // is on the executing stack, or as a handle in vm code, this constant pool
209   // can't be removed from the set of previous versions saved in the instance
210   // class.
211   bool on_stack() const;
212   bool is_maybe_on_stack() const;
213   void set_on_stack(const bool value);
214 
215   // Faster than MetaspaceObj::is_shared() - used by set_on_stack()
216   bool is_shared() const                     { return (_flags & _is_shared) != 0; }
217 
218   bool has_dynamic_constant() const       { return (_flags & _has_dynamic_constant) != 0; }
219   void set_has_dynamic_constant()         { _flags |= _has_dynamic_constant; }
220 
221   bool is_for_method_handle_intrinsic() const  { return (_flags & _is_for_method_handle_intrinsic) != 0; }
222   void set_is_for_method_handle_intrinsic()    { _flags |= _is_for_method_handle_intrinsic; }
223 
224   // Klass holding pool
225   InstanceKlass* pool_holder() const      { return _pool_holder; }
226   void set_pool_holder(InstanceKlass* k)  { _pool_holder = k; }
227   InstanceKlass** pool_holder_addr()      { return &_pool_holder; }
228 
229   // Interpreter runtime support
230   ConstantPoolCache* cache() const        { return _cache; }
231   void set_cache(ConstantPoolCache* cache){ _cache = cache; }
232 
233   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
234   virtual MetaspaceObj::Type type() const { return ConstantPoolType; }
235 
236   // Create object cache in the constant pool
237   void initialize_resolved_references(ClassLoaderData* loader_data,
238                                       const intStack& reference_map,
239                                       int constant_pool_map_length,
240                                       TRAPS);
241 
242   // resolved strings, methodHandles and callsite objects from the constant pool
243   objArrayOop resolved_references()  const;
244   objArrayOop resolved_references_or_null()  const;
245   oop resolved_reference_at(int obj_index) const;
246   oop set_resolved_reference_at(int index, oop new_value);
247 
248   // mapping resolved object array indexes to cp indexes and back.
249   int object_to_cp_index(int index)         { return reference_map()->at(index); }
250   int cp_to_object_index(int index);
251 
252   void set_resolved_klasses(Array<Klass*>* rk)  { _resolved_klasses = rk; }
253   Array<Klass*>* resolved_klasses() const       { return _resolved_klasses; }
254   void allocate_resolved_klasses(ClassLoaderData* loader_data, int num_klasses, TRAPS);
255   void initialize_unresolved_klasses(ClassLoaderData* loader_data, TRAPS);
256 
257   // Given the per-instruction index of an indy instruction, report the
258   // main constant pool entry for its bootstrap specifier.
259   // From there, uncached_name/signature_ref_at will get the name/type.
260   inline u2 invokedynamic_bootstrap_ref_index_at(int indy_index) const;
261 
262   // Assembly code support
263   static ByteSize tags_offset()         { return byte_offset_of(ConstantPool, _tags); }
264   static ByteSize cache_offset()        { return byte_offset_of(ConstantPool, _cache); }
265   static ByteSize pool_holder_offset()  { return byte_offset_of(ConstantPool, _pool_holder); }
266   static ByteSize resolved_klasses_offset()    { return byte_offset_of(ConstantPool, _resolved_klasses); }
267 
268   // Storing constants
269 
270   // For temporary use while constructing constant pool. Used during a retransform/class redefinition as well.
271   void klass_index_at_put(int cp_index, int name_index) {
272     tag_at_put(cp_index, JVM_CONSTANT_ClassIndex);
273     *int_at_addr(cp_index) = name_index;
274   }
275 
276   // Hidden class support:
277   void klass_at_put(int class_index, Klass* k);
278 
279   void unresolved_klass_at_put(int cp_index, int name_index, int resolved_klass_index) {
280     release_tag_at_put(cp_index, JVM_CONSTANT_UnresolvedClass);
281 
282     assert((name_index & 0xffff0000) == 0, "must be");
283     assert((resolved_klass_index & 0xffff0000) == 0, "must be");
284     *int_at_addr(cp_index) =
285       build_int_from_shorts((jushort)resolved_klass_index, (jushort)name_index);
286   }
287 
288   void method_handle_index_at_put(int cp_index, int ref_kind, int ref_index) {
289     tag_at_put(cp_index, JVM_CONSTANT_MethodHandle);
290     *int_at_addr(cp_index) = ((jint) ref_index<<16) | ref_kind;
291   }
292 
293   void method_type_index_at_put(int cp_index, int ref_index) {
294     tag_at_put(cp_index, JVM_CONSTANT_MethodType);
295     *int_at_addr(cp_index) = ref_index;
296   }
297 
298   void dynamic_constant_at_put(int cp_index, int bsms_attribute_index, int name_and_type_index) {
299     tag_at_put(cp_index, JVM_CONSTANT_Dynamic);
300     *int_at_addr(cp_index) = ((jint) name_and_type_index<<16) | bsms_attribute_index;
301   }
302 
303   void invoke_dynamic_at_put(int cp_index, int bsms_attribute_index, int name_and_type_index) {
304     tag_at_put(cp_index, JVM_CONSTANT_InvokeDynamic);
305     *int_at_addr(cp_index) = ((jint) name_and_type_index<<16) | bsms_attribute_index;
306   }
307 
308   void unresolved_string_at_put(int cp_index, Symbol* s) {
309     assert(s->refcount() != 0, "should have nonzero refcount");
310     // Note that release_tag_at_put is not needed here because this is called only
311     // when constructing a ConstantPool in a single thread, with no possibility
312     // of concurrent access.
313     tag_at_put(cp_index, JVM_CONSTANT_String);
314     *symbol_at_addr(cp_index) = s;
315   }
316 
317   void int_at_put(int cp_index, jint i) {
318     tag_at_put(cp_index, JVM_CONSTANT_Integer);
319     *int_at_addr(cp_index) = i;
320   }
321 
322   void long_at_put(int cp_index, jlong l) {
323     tag_at_put(cp_index, JVM_CONSTANT_Long);
324     // *long_at_addr(which) = l;
325     Bytes::put_native_u8((address)long_at_addr(cp_index), *((u8*) &l));
326   }
327 
328   void float_at_put(int cp_index, jfloat f) {
329     tag_at_put(cp_index, JVM_CONSTANT_Float);
330     *float_at_addr(cp_index) = f;
331   }
332 
333   void double_at_put(int cp_index, jdouble d) {
334     tag_at_put(cp_index, JVM_CONSTANT_Double);
335     // *double_at_addr(which) = d;
336     // u8 temp = *(u8*) &d;
337     Bytes::put_native_u8((address) double_at_addr(cp_index), *((u8*) &d));
338   }
339 
340   Symbol** symbol_at_addr(int cp_index) const {
341     assert(is_within_bounds(cp_index), "index out of bounds");
342     return (Symbol**) &base()[cp_index];
343   }
344 
345   void symbol_at_put(int cp_index, Symbol* s) {
346     assert(s->refcount() != 0, "should have nonzero refcount");
347     tag_at_put(cp_index, JVM_CONSTANT_Utf8);
348     *symbol_at_addr(cp_index) = s;
349   }
350 
351   void string_at_put(int obj_index, oop str);
352 
353   // For temporary use while constructing constant pool
354   void string_index_at_put(int cp_index, int string_index) {
355     tag_at_put(cp_index, JVM_CONSTANT_StringIndex);
356     *int_at_addr(cp_index) = string_index;
357   }
358 
359   void field_at_put(int cp_index, int class_index, int name_and_type_index) {
360     tag_at_put(cp_index, JVM_CONSTANT_Fieldref);
361     *int_at_addr(cp_index) = ((jint) name_and_type_index<<16) | class_index;
362   }
363 
364   void method_at_put(int cp_index, int class_index, int name_and_type_index) {
365     tag_at_put(cp_index, JVM_CONSTANT_Methodref);
366     *int_at_addr(cp_index) = ((jint) name_and_type_index<<16) | class_index;
367   }
368 
369   void interface_method_at_put(int cp_index, int class_index, int name_and_type_index) {
370     tag_at_put(cp_index, JVM_CONSTANT_InterfaceMethodref);
371     *int_at_addr(cp_index) = ((jint) name_and_type_index<<16) | class_index;  // Not so nice
372   }
373 
374   void name_and_type_at_put(int cp_index, int name_index, int signature_index) {
375     tag_at_put(cp_index, JVM_CONSTANT_NameAndType);
376     *int_at_addr(cp_index) = ((jint) signature_index<<16) | name_index;  // Not so nice
377   }
378 
379   // Tag query
380 
381   constantTag tag_at(int cp_index) const { return (constantTag)tags()->at_acquire(cp_index); }
382 
383   // Fetching constants
384 
385   Klass* klass_at(int cp_index, TRAPS) {
386     constantPoolHandle h_this(THREAD, this);
387     return klass_at_impl(h_this, cp_index, THREAD);
388   }
389 
390   CPKlassSlot klass_slot_at(int cp_index) const {
391     assert(tag_at(cp_index).is_unresolved_klass() || tag_at(cp_index).is_klass(),
392            "Corrupted constant pool");
393     int value = *int_at_addr(cp_index);
394     int name_index = extract_high_short_from_int(value);
395     int resolved_klass_index = extract_low_short_from_int(value);
396     return CPKlassSlot(name_index, resolved_klass_index);
397   }
398 
399   Symbol* klass_name_at(int cp_index) const;  // Returns the name, w/o resolving.
400   int klass_name_index_at(int cp_index) const {
401     return klass_slot_at(cp_index).name_index();
402   }
403 
404   Klass* resolved_klass_at(int cp_index) const;  // Used by Compiler
405 
406   // RedefineClasses() API support:
407   Symbol* klass_at_noresolve(int cp_index) { return klass_name_at(cp_index); }
408   void temp_unresolved_klass_at_put(int cp_index, int name_index) {
409     // Used only during constant pool merging for class redefinition. The resolved klass index
410     // will be initialized later by a call to initialize_unresolved_klasses().
411     unresolved_klass_at_put(cp_index, name_index, CPKlassSlot::_temp_resolved_klass_index);
412   }
413 
414   jint int_at(int cp_index) const {
415     assert(tag_at(cp_index).is_int(), "Corrupted constant pool");
416     return *int_at_addr(cp_index);
417   }
418 
419   jlong long_at(int cp_index) {
420     assert(tag_at(cp_index).is_long(), "Corrupted constant pool");
421     // return *long_at_addr(cp_index);
422     u8 tmp = Bytes::get_native_u8((address)&base()[cp_index]);
423     return *((jlong*)&tmp);
424   }
425 
426   jfloat float_at(int cp_index) {
427     assert(tag_at(cp_index).is_float(), "Corrupted constant pool");
428     return *float_at_addr(cp_index);
429   }
430 
431   jdouble double_at(int cp_index) {
432     assert(tag_at(cp_index).is_double(), "Corrupted constant pool");
433     u8 tmp = Bytes::get_native_u8((address)&base()[cp_index]);
434     return *((jdouble*)&tmp);
435   }
436 
437   Symbol* symbol_at(int cp_index) const {
438     assert(tag_at(cp_index).is_utf8(), "Corrupted constant pool");
439     return *symbol_at_addr(cp_index);
440   }
441 
442   oop string_at(int cp_index, int obj_index, TRAPS) {
443     constantPoolHandle h_this(THREAD, this);
444     return string_at_impl(h_this, cp_index, obj_index, THREAD);
445   }
446   oop string_at(int cp_index, TRAPS) {
447     int obj_index = cp_to_object_index(cp_index);
448     return string_at(cp_index, obj_index, THREAD);
449   }
450 
451   // Version that can be used before string oop array is created.
452   oop uncached_string_at(int cp_index, TRAPS);
453 
454   // only called when we are sure a string entry is already resolved (via an
455   // earlier string_at call.
456   oop resolved_string_at(int cp_index) {
457     assert(tag_at(cp_index).is_string(), "Corrupted constant pool");
458     // Must do an acquire here in case another thread resolved the klass
459     // behind our back, lest we later load stale values thru the oop.
460     // we might want a volatile_obj_at in ObjArrayKlass.
461     int obj_index = cp_to_object_index(cp_index);
462     return resolved_reference_at(obj_index);
463   }
464 
465   Symbol* unresolved_string_at(int cp_index) {
466     assert(tag_at(cp_index).is_string(), "Corrupted constant pool");
467     return *symbol_at_addr(cp_index);
468   }
469 
470   // Returns an UTF8 for a CONSTANT_String entry at a given index.
471   // UTF8 char* representation was chosen to avoid conversion of
472   // java_lang_Strings at resolved entries into Symbol*s
473   // or vice versa.
474   char* string_at_noresolve(int cp_index);
475 
476   jint name_and_type_at(int cp_index) {
477     assert(tag_at(cp_index).is_name_and_type(), "Corrupted constant pool");
478     return *int_at_addr(cp_index);
479   }
480 
481   int method_handle_ref_kind_at(int cp_index) {
482     assert(tag_at(cp_index).is_method_handle() ||
483            tag_at(cp_index).is_method_handle_in_error(), "Corrupted constant pool");
484     return extract_low_short_from_int(*int_at_addr(cp_index));  // mask out unwanted ref_index bits
485   }
486   int method_handle_index_at(int cp_index) {
487     assert(tag_at(cp_index).is_method_handle() ||
488            tag_at(cp_index).is_method_handle_in_error(), "Corrupted constant pool");
489     return extract_high_short_from_int(*int_at_addr(cp_index));  // shift out unwanted ref_kind bits
490   }
491   int method_type_index_at(int cp_index) {
492     assert(tag_at(cp_index).is_method_type() ||
493            tag_at(cp_index).is_method_type_in_error(), "Corrupted constant pool");
494     return *int_at_addr(cp_index);
495   }
496 
497   // Derived queries:
498   Symbol* method_handle_name_ref_at(int cp_index) {
499     int member = method_handle_index_at(cp_index);
500     return uncached_name_ref_at(member);
501   }
502   Symbol* method_handle_signature_ref_at(int cp_index) {
503     int member = method_handle_index_at(cp_index);
504     return uncached_signature_ref_at(member);
505   }
506   u2 method_handle_klass_index_at(int cp_index) {
507     int member = method_handle_index_at(cp_index);
508     return uncached_klass_ref_index_at(member);
509   }
510   Symbol* method_type_signature_at(int cp_index) {
511     int sym = method_type_index_at(cp_index);
512     return symbol_at(sym);
513   }
514 
515   u2 bootstrap_name_and_type_ref_index_at(int cp_index) {
516     assert(tag_at(cp_index).has_bootstrap(), "Corrupted constant pool");
517     return extract_high_short_from_int(*int_at_addr(cp_index));
518   }
519   u2 bootstrap_methods_attribute_index(int cp_index) {
520     assert(tag_at(cp_index).has_bootstrap(), "Corrupted constant pool");
521     return extract_low_short_from_int(*int_at_addr(cp_index));
522   }
523   int bootstrap_operand_base(int cp_index) {
524     int bsms_attribute_index = bootstrap_methods_attribute_index(cp_index);
525     return operand_offset_at(operands(), bsms_attribute_index);
526   }
527   // The first part of the operands array consists of an index into the second part.
528   // Extract a 32-bit index value from the first part.
529   static int operand_offset_at(Array<u2>* operands, int bsms_attribute_index) {
530     int n = (bsms_attribute_index * 2);
531     assert(n >= 0 && n+2 <= operands->length(), "oob");
532     // The first 32-bit index points to the beginning of the second part
533     // of the operands array.  Make sure this index is in the first part.
534     DEBUG_ONLY(int second_part = build_int_from_shorts(operands->at(0),
535                                                        operands->at(1)));
536     assert(second_part == 0 || n+2 <= second_part, "oob (2)");
537     int offset = build_int_from_shorts(operands->at(n+0),
538                                        operands->at(n+1));
539     // The offset itself must point into the second part of the array.
540     assert(offset == 0 || (offset >= second_part && offset <= operands->length()), "oob (3)");
541     return offset;
542   }
543   static void operand_offset_at_put(Array<u2>* operands, int bsms_attribute_index, int offset) {
544     int n = bsms_attribute_index * 2;
545     assert(n >= 0 && n+2 <= operands->length(), "oob");
546     operands->at_put(n+0, extract_low_short_from_int(offset));
547     operands->at_put(n+1, extract_high_short_from_int(offset));
548   }
549   static int operand_array_length(Array<u2>* operands) {
550     if (operands == nullptr || operands->length() == 0)  return 0;
551     int second_part = operand_offset_at(operands, 0);
552     return (second_part / 2);
553   }
554 
555 #ifdef ASSERT
556   // operand tuples fit together exactly, end to end
557   static int operand_limit_at(Array<u2>* operands, int bsms_attribute_index) {
558     int nextidx = bsms_attribute_index + 1;
559     if (nextidx == operand_array_length(operands))
560       return operands->length();
561     else
562       return operand_offset_at(operands, nextidx);
563   }
564   int bootstrap_operand_limit(int cp_index) {
565     int bsms_attribute_index = bootstrap_methods_attribute_index(cp_index);
566     return operand_limit_at(operands(), bsms_attribute_index);
567   }
568 #endif //ASSERT
569 
570   // Layout of InvokeDynamic and Dynamic bootstrap method specifier
571   // data in second part of operands array.  This encodes one record in
572   // the BootstrapMethods attribute.  The whole specifier also includes
573   // the name and type information from the main constant pool entry.
574   enum {
575          _indy_bsm_offset  = 0,  // CONSTANT_MethodHandle bsm
576          _indy_argc_offset = 1,  // u2 argc
577          _indy_argv_offset = 2   // u2 argv[argc]
578   };
579 
580   // These functions are used in RedefineClasses for CP merge
581 
582   int operand_offset_at(int bsms_attribute_index) {
583     assert(0 <= bsms_attribute_index &&
584            bsms_attribute_index < operand_array_length(operands()),
585            "Corrupted CP operands");
586     return operand_offset_at(operands(), bsms_attribute_index);
587   }
588   u2 operand_bootstrap_method_ref_index_at(int bsms_attribute_index) {
589     int offset = operand_offset_at(bsms_attribute_index);
590     return operands()->at(offset + _indy_bsm_offset);
591   }
592   u2 operand_argument_count_at(int bsms_attribute_index) {
593     int offset = operand_offset_at(bsms_attribute_index);
594     u2 argc = operands()->at(offset + _indy_argc_offset);
595     return argc;
596   }
597   u2 operand_argument_index_at(int bsms_attribute_index, int j) {
598     int offset = operand_offset_at(bsms_attribute_index);
599     return operands()->at(offset + _indy_argv_offset + j);
600   }
601   int operand_next_offset_at(int bsms_attribute_index) {
602     int offset = operand_offset_at(bsms_attribute_index) + _indy_argv_offset
603                    + operand_argument_count_at(bsms_attribute_index);
604     return offset;
605   }
606   // Compare a bootstrap specifier data in the operands arrays
607   bool compare_operand_to(int bsms_attribute_index1, const constantPoolHandle& cp2,
608                           int bsms_attribute_index2);
609   // Find a bootstrap specifier data in the operands array
610   int find_matching_operand(int bsms_attribute_index, const constantPoolHandle& search_cp,
611                             int operands_cur_len);
612   // Resize the operands array with delta_len and delta_size
613   void resize_operands(int delta_len, int delta_size, TRAPS);
614   // Extend the operands array with the length and size of the ext_cp operands
615   void extend_operands(const constantPoolHandle& ext_cp, TRAPS);
616   // Shrink the operands array to a smaller array with new_len length
617   void shrink_operands(int new_len, TRAPS);
618 
619   u2 bootstrap_method_ref_index_at(int cp_index) {
620     assert(tag_at(cp_index).has_bootstrap(), "Corrupted constant pool");
621     int op_base = bootstrap_operand_base(cp_index);
622     return operands()->at(op_base + _indy_bsm_offset);
623   }
624   u2 bootstrap_argument_count_at(int cp_index) {
625     assert(tag_at(cp_index).has_bootstrap(), "Corrupted constant pool");
626     int op_base = bootstrap_operand_base(cp_index);
627     u2 argc = operands()->at(op_base + _indy_argc_offset);
628     DEBUG_ONLY(int end_offset = op_base + _indy_argv_offset + argc;
629                int next_offset = bootstrap_operand_limit(cp_index));
630     assert(end_offset == next_offset, "matched ending");
631     return argc;
632   }
633   u2 bootstrap_argument_index_at(int cp_index, int j) {
634     int op_base = bootstrap_operand_base(cp_index);
635     DEBUG_ONLY(int argc = operands()->at(op_base + _indy_argc_offset));
636     assert((uint)j < (uint)argc, "oob");
637     return operands()->at(op_base + _indy_argv_offset + j);
638   }
639 
640   // The following methods (name/signature/klass_ref_at, klass_ref_at_noresolve,
641   // name_and_type_ref_index_at) all expect to be passed indices obtained
642   // directly from the bytecode.
643   // If the indices are meant to refer to fields or methods, they are
644   // actually rewritten indices that point to entries in their respective structures
645   // i.e. ResolvedMethodEntries or ResolvedFieldEntries.
646   // The routine to_cp_index manages the adjustment
647   // of these values back to constant pool indices.
648 
649   // There are also "uncached" versions which do not adjust the operand index; see below.
650 
651   // Lookup for entries consisting of (klass_index, name_and_type index)
652   Klass* klass_ref_at(int which, Bytecodes::Code code, TRAPS);
653   Symbol* klass_ref_at_noresolve(int which, Bytecodes::Code code);
654   Symbol* name_ref_at(int which, Bytecodes::Code code) {
655     int name_index = name_ref_index_at(name_and_type_ref_index_at(which, code));
656     return symbol_at(name_index);
657   }
658   Symbol* signature_ref_at(int which, Bytecodes::Code code) {
659     int signature_index = signature_ref_index_at(name_and_type_ref_index_at(which, code));
660     return symbol_at(signature_index);
661   }
662 
663   u2 klass_ref_index_at(int which, Bytecodes::Code code);
664   u2 name_and_type_ref_index_at(int which, Bytecodes::Code code);
665 
666   constantTag tag_ref_at(int cp_cache_index, Bytecodes::Code code);
667 
668   int to_cp_index(int which, Bytecodes::Code code);
669 
670   bool is_resolved(int which, Bytecodes::Code code);
671 
672   // Lookup for entries consisting of (name_index, signature_index)
673   u2 name_ref_index_at(int cp_index);            // ==  low-order jshort of name_and_type_at(cp_index)
674   u2 signature_ref_index_at(int cp_index);       // == high-order jshort of name_and_type_at(cp_index)
675 
676   BasicType basic_type_for_signature_at(int cp_index) const;
677 
678   // Resolve string constants (to prevent allocation during compilation)
679   void resolve_string_constants(TRAPS) {
680     constantPoolHandle h_this(THREAD, this);
681     resolve_string_constants_impl(h_this, CHECK);
682   }
683 
684 #if INCLUDE_CDS
685   // CDS support
686   objArrayOop prepare_resolved_references_for_archiving() NOT_CDS_JAVA_HEAP_RETURN_(nullptr);
687   void add_dumped_interned_strings() NOT_CDS_JAVA_HEAP_RETURN;
688   void remove_unshareable_info();
689   void restore_unshareable_info(TRAPS);
690 private:
691   void remove_unshareable_entries();
692   void remove_resolved_klass_if_non_deterministic(int cp_index);
693   template <typename Function> void iterate_archivable_resolved_references(Function function);
694 #endif
695 
696  private:
697   enum { _no_index_sentinel = -1, _possible_index_sentinel = -2 };
698  public:
699 
700   // Get the tag for a constant, which may involve a constant dynamic
701   constantTag constant_tag_at(int cp_index);
702   // Get the basic type for a constant, which may involve a constant dynamic
703   BasicType basic_type_for_constant_at(int cp_index);
704 
705   // Resolve late bound constants.
706   oop resolve_constant_at(int cp_index, TRAPS) {
707     constantPoolHandle h_this(THREAD, this);
708     return resolve_constant_at_impl(h_this, cp_index, _no_index_sentinel, nullptr, THREAD);
709   }
710 
711   oop resolve_cached_constant_at(int cache_index, TRAPS) {
712     constantPoolHandle h_this(THREAD, this);
713     return resolve_constant_at_impl(h_this, _no_index_sentinel, cache_index, nullptr, THREAD);
714   }
715 
716   oop resolve_possibly_cached_constant_at(int cp_index, TRAPS) {
717     constantPoolHandle h_this(THREAD, this);
718     return resolve_constant_at_impl(h_this, cp_index, _possible_index_sentinel, nullptr, THREAD);
719   }
720 
721   oop find_cached_constant_at(int cp_index, bool& found_it, TRAPS) {
722     constantPoolHandle h_this(THREAD, this);
723     return resolve_constant_at_impl(h_this, cp_index, _possible_index_sentinel, &found_it, THREAD);
724   }
725 
726   void copy_bootstrap_arguments_at(int cp_index,
727                                    int start_arg, int end_arg,
728                                    objArrayHandle info, int pos,
729                                    bool must_resolve, Handle if_not_available, TRAPS) {
730     constantPoolHandle h_this(THREAD, this);
731     copy_bootstrap_arguments_at_impl(h_this, cp_index, start_arg, end_arg,
732                                      info, pos, must_resolve, if_not_available, THREAD);
733   }
734 
735   // Klass name matches name at offset
736   bool klass_name_at_matches(const InstanceKlass* k, int cp_index);
737 
738   // Sizing
739   int length() const                   { return _length; }
740   void set_length(int length)          { _length = length; }
741 
742   // Tells whether index is within bounds.
743   bool is_within_bounds(int index) const {
744     return 0 <= index && index < length();
745   }
746 
747   // Sizing (in words)
748   static int header_size()             {
749     return align_up((int)sizeof(ConstantPool), wordSize) / wordSize;
750   }
751   static int size(int length)          { return align_metadata_size(header_size() + length); }
752   int size() const                     { return size(length()); }
753 
754   // ConstantPools should be stored in the read-only region of CDS archive.
755   static bool is_read_only_by_default() { return true; }
756 
757   friend class ClassFileParser;
758   friend class SystemDictionary;
759 
760   // Used by CDS. These classes need to access the private ConstantPool() constructor.
761   template <class T> friend class CppVtableTesterA;
762   template <class T> friend class CppVtableTesterB;
763   template <class T> friend class CppVtableCloner;
764 
765   // Used by compiler to prevent classloading.
766   static Method*          method_at_if_loaded      (const constantPoolHandle& this_cp, int which);
767   static bool       has_appendix_at_if_loaded      (const constantPoolHandle& this_cp, int which, Bytecodes::Code code);
768   static oop            appendix_at_if_loaded      (const constantPoolHandle& this_cp, int which, Bytecodes::Code code);
769   static bool has_local_signature_at_if_loaded     (const constantPoolHandle& this_cp, int which, Bytecodes::Code code);
770   static Klass*            klass_at_if_loaded      (const constantPoolHandle& this_cp, int which);
771 
772   // Routines currently used for annotations (only called by jvm.cpp) but which might be used in the
773   // future by other Java code. These take constant pool indices rather than
774   // constant pool cache indices as do the peer methods above.
775   Symbol* uncached_klass_ref_at_noresolve(int cp_index);
776   Symbol* uncached_name_ref_at(int cp_index) {
777     int name_index = name_ref_index_at(uncached_name_and_type_ref_index_at(cp_index));
778     return symbol_at(name_index);
779   }
780   Symbol* uncached_signature_ref_at(int cp_index) {
781     int signature_index = signature_ref_index_at(uncached_name_and_type_ref_index_at(cp_index));
782     return symbol_at(signature_index);
783   }
784   u2 uncached_klass_ref_index_at(int cp_index);
785   u2 uncached_name_and_type_ref_index_at(int cp_index);
786 
787   // Sharing
788   int pre_resolve_shared_klasses(TRAPS);
789 
790   // Debugging
791   const char* printable_name_at(int cp_index) PRODUCT_RETURN_NULL;
792 
793  private:
794 
795   void set_resolved_references(OopHandle s) { _cache->set_resolved_references(s); }
796   Array<u2>* reference_map() const        {  return (_cache == nullptr) ? nullptr :  _cache->reference_map(); }
797   void set_reference_map(Array<u2>* o)    { _cache->set_reference_map(o); }
798 
799   // Used while constructing constant pool (only by ClassFileParser)
800   jint klass_index_at(int cp_index) {
801     assert(tag_at(cp_index).is_klass_index(), "Corrupted constant pool");
802     return *int_at_addr(cp_index);
803   }
804 
805   jint string_index_at(int cp_index) {
806     assert(tag_at(cp_index).is_string_index(), "Corrupted constant pool");
807     return *int_at_addr(cp_index);
808   }
809 
810   // Performs the LinkResolver checks
811   static void verify_constant_pool_resolve(const constantPoolHandle& this_cp, Klass* klass, TRAPS);
812 
813   // Implementation of methods that needs an exposed 'this' pointer, in order to
814   // handle GC while executing the method
815   static Klass* klass_at_impl(const constantPoolHandle& this_cp, int cp_index, TRAPS);
816   static oop string_at_impl(const constantPoolHandle& this_cp, int cp_index, int obj_index, TRAPS);
817 
818   static void trace_class_resolution(const constantPoolHandle& this_cp, Klass* k);
819 
820   // Resolve string constants (to prevent allocation during compilation)
821   static void resolve_string_constants_impl(const constantPoolHandle& this_cp, TRAPS);
822 
823   static oop resolve_constant_at_impl(const constantPoolHandle& this_cp, int cp_index, int cache_index,
824                                       bool* status_return, TRAPS);
825   static void copy_bootstrap_arguments_at_impl(const constantPoolHandle& this_cp, int cp_index,
826                                                int start_arg, int end_arg,
827                                                objArrayHandle info, int pos,
828                                                bool must_resolve, Handle if_not_available, TRAPS);
829 
830   // Exception handling
831   static void save_and_throw_exception(const constantPoolHandle& this_cp, int cp_index, constantTag tag, TRAPS);
832 
833  public:
834   // Exception handling
835   static void throw_resolution_error(const constantPoolHandle& this_cp, int which, TRAPS);
836 
837   // Merging ConstantPool* support:
838   bool compare_entry_to(int index1, const constantPoolHandle& cp2, int index2);
839   void copy_cp_to(int start_cpi, int end_cpi, const constantPoolHandle& to_cp, int to_cpi, TRAPS) {
840     constantPoolHandle h_this(THREAD, this);
841     copy_cp_to_impl(h_this, start_cpi, end_cpi, to_cp, to_cpi, THREAD);
842   }
843   static void copy_cp_to_impl(const constantPoolHandle& from_cp, int start_cpi, int end_cpi, const constantPoolHandle& to_cp, int to_cpi, TRAPS);
844   static void copy_entry_to(const constantPoolHandle& from_cp, int from_cpi, const constantPoolHandle& to_cp, int to_cpi);
845   static void copy_operands(const constantPoolHandle& from_cp, const constantPoolHandle& to_cp, TRAPS);
846   int  find_matching_entry(int pattern_i, const constantPoolHandle& search_cp);
847   int  version() const                    { return _saved._version; }
848   void set_version(int version)           { _saved._version = version; }
849   void increment_and_save_version(int version) {
850     _saved._version = version >= 0 ? (version + 1) : version;  // keep overflow
851   }
852 
853   void set_resolved_reference_length(int length) { _saved._resolved_reference_length = length; }
854   int  resolved_reference_length() const  { return _saved._resolved_reference_length; }
855 
856   // Decrease ref counts of symbols that are in the constant pool
857   // when the holder class is unloaded
858   void unreference_symbols();
859 
860   // Deallocate constant pool for RedefineClasses
861   void deallocate_contents(ClassLoaderData* loader_data);
862   void release_C_heap_structures();
863 
864   // JVMTI access - GetConstantPool, RetransformClasses, ...
865   friend class JvmtiConstantPoolReconstituter;
866 
867  private:
868   class SymbolHash: public CHeapObj<mtSymbol> {
869     ResourceHashtable<const Symbol*, u2, 256, AnyObj::C_HEAP, mtSymbol, Symbol::compute_hash> _table;
870 
871    public:
872     void add_if_absent(const Symbol* sym, u2 value) {
873       bool created;
874       _table.put_if_absent(sym, value, &created);
875     }
876 
877     u2 symbol_to_value(const Symbol* sym) {
878       u2* value = _table.get(sym);
879       return (value == nullptr) ? 0 : *value;
880     }
881   }; // End SymbolHash class
882 
883   jint cpool_entry_size(jint idx);
884   jint hash_entries_to(SymbolHash *symmap, SymbolHash *classmap);
885 
886   // Copy cpool bytes into byte array.
887   // Returns:
888   //  int > 0, count of the raw cpool bytes that have been copied
889   //        0, OutOfMemory error
890   //       -1, Internal error
891   int  copy_cpool_bytes(int cpool_size,
892                         SymbolHash* tbl,
893                         unsigned char *bytes);
894 
895  public:
896   // Verify
897   void verify_on(outputStream* st);
898 
899   // Printing
900   void print_on(outputStream* st) const;
901   void print_value_on(outputStream* st) const;
902   void print_entry_on(int index, outputStream* st);
903 
904   const char* internal_name() const { return "{constant pool}"; }
905 
906   // ResolvedFieldEntry getters
907   inline ResolvedFieldEntry* resolved_field_entry_at(int field_index);
908   inline int resolved_field_entries_length() const;
909 
910   // ResolvedMethodEntry getters
911   inline ResolvedMethodEntry* resolved_method_entry_at(int method_index);
912   inline int resolved_method_entries_length() const;
913   inline oop appendix_if_resolved(int method_index) const;
914 
915   // ResolvedIndyEntry getters
916   inline ResolvedIndyEntry* resolved_indy_entry_at(int index);
917   inline int resolved_indy_entries_length() const;
918   inline oop resolved_reference_from_indy(int index) const;
919   inline oop resolved_reference_from_method(int index) const;
920 };
921 
922 #endif // SHARE_OOPS_CONSTANTPOOL_HPP