/*

 * 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.

 *

 */

#include "memory/allocation.hpp"

#include "oops/arrayOop.hpp"

#include "oops/cpCache.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oopHandle.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayOop.hpp"

#include "runtime/handles.hpp"

#include "utilities/align.hpp"

#include "utilities/bytes.hpp"

#include "utilities/constantTag.hpp"

// A ConstantPool is an array containing class constants as described in the

// class file.

//

// Most of the constant pool entries are written during class parsing, which

// is safe.  For klass types, the constant pool entry is

// modified when the entry is resolved.  If a klass constant pool

// entry is read without a lock, only the resolved state guarantees that

// the entry in the constant pool is a klass object and not a Symbol*.

class SymbolHashMap;

class CPSlot {

 friend class ConstantPool;

  intptr_t _ptr;

  enum TagBits  {_pseudo_bit = 1};

 public:

  CPSlot(intptr_t ptr): _ptr(ptr) {}

  CPSlot(Symbol* ptr, int tag_bits = 0): _ptr((intptr_t)ptr | tag_bits) {}

  intptr_t value()   { return _ptr; }

  bool is_pseudo_string() { return (_ptr & _pseudo_bit) != 0; }

  Symbol* get_symbol() {

    return (Symbol*)(_ptr & ~_pseudo_bit);

  }

};

// This represents a JVM_CONSTANT_Class, JVM_CONSTANT_UnresolvedClass, or

// JVM_CONSTANT_UnresolvedClassInError slot in the constant pool.

class CPKlassSlot {

  // cp->symbol_at(_name_index) gives the name of the class.

  int _name_index;

  // cp->_resolved_klasses->at(_resolved_klass_index) gives the Klass* for the class.

  int _resolved_klass_index;

public:

  enum {

    // This is used during constant pool merging where the resolved klass index is

    // not yet known, and will be computed at a later stage (during a call to

    // initialize_unresolved_klasses()).

    _temp_resolved_klass_index = 0xffff

  };

  CPKlassSlot(int n, int rk) {

    _name_index = n;

    _resolved_klass_index = rk;

  }

  int name_index() const {

    return _name_index;

  }

  int resolved_klass_index() const {

    assert(_resolved_klass_index != _temp_resolved_klass_index, "constant pool merging was incomplete");

    return _resolved_klass_index;

  }

};

class KlassSizeStats;

class ConstantPool : public Metadata {

  friend class VMStructs;

  friend class JVMCIVMStructs;

  friend class BytecodeInterpreter;  // Directly extracts a klass in the pool for fast instanceof/checkcast

  friend class Universe;             // For null constructor

 private:

  // If you add a new field that points to any metaspace object, you

  // must add this field to ConstantPool::metaspace_pointers_do().

  Array<u1>*           _tags;        // the tag array describing the constant pool's contents

  ConstantPoolCache*   _cache;       // the cache holding interpreter runtime information

  InstanceKlass*       _pool_holder; // the corresponding class

  Array<u2>*           _operands;    // for variable-sized (InvokeDynamic) nodes, usually empty

  // Consider using an array of compressed klass pointers to

  // save space on 64-bit platforms.

  Array<Klass*>*       _resolved_klasses;

  enum {

    _has_preresolution    = 1,       // Flags

    _on_stack             = 2,

    _is_shared            = 4,

    _has_dynamic_constant = 8

  };

  int                  _flags;  // old fashioned bit twiddling

  int                  _length; // number of elements in the array

  union {

    // set for CDS to restore resolved references

    int                _resolved_reference_length;

    // keeps version number for redefined classes (used in backtrace)

    int                _version;

  } _saved;

  void set_tags(Array<u1>* tags)               { _tags = tags; }

  void tag_at_put(int which, jbyte t)          { tags()->at_put(which, t); }

  void release_tag_at_put(int which, jbyte t);

  u1* tag_addr_at(int which) const             { return tags()->adr_at(which); }

  void set_operands(Array<u2>* operands)       { _operands = operands; }

  int flags() const                            { return _flags; }

  void set_flags(int f)                        { _flags = f; }

 private:

  intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(ConstantPool)); }

  CPSlot slot_at(int which) const;

  void slot_at_put(int which, CPSlot s) const {

    assert(is_within_bounds(which), "index out of bounds");

    assert(s.value() != 0, "Caught something");

    *(intptr_t*)&base()[which] = s.value();

  }

  intptr_t* obj_at_addr(int which) const {

    assert(is_within_bounds(which), "index out of bounds");

    return (intptr_t*) &base()[which];

  }

  jint* int_at_addr(int which) const {

    assert(is_within_bounds(which), "index out of bounds");

    return (jint*) &base()[which];

  }

  jlong* long_at_addr(int which) const {

    assert(is_within_bounds(which), "index out of bounds");

    return (jlong*) &base()[which];

  }

  jfloat* float_at_addr(int which) const {

    assert(is_within_bounds(which), "index out of bounds");

    return (jfloat*) &base()[which];

  }

  jdouble* double_at_addr(int which) const {

    assert(is_within_bounds(which), "index out of bounds");

    return (jdouble*) &base()[which];

  }

  ConstantPool(Array<u1>* tags);

  ConstantPool() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }

 public:

  static ConstantPool* allocate(ClassLoaderData* loader_data, int length, TRAPS);

  bool is_constantPool() const volatile     { return true; }

  Array<u1>* tags() const                   { return _tags; }

  Array<u2>* operands() const               { return _operands; }

  bool has_preresolution() const            { return (_flags & _has_preresolution) != 0; }

  void set_has_preresolution() {

    assert(!is_shared(), "should never be called on shared ConstantPools");

    _flags |= _has_preresolution;

  }

  // Redefine classes support.  If a method refering to this constant pool

  // is on the executing stack, or as a handle in vm code, this constant pool

  // can't be removed from the set of previous versions saved in the instance

  // class.

  bool on_stack() const                      { return (_flags &_on_stack) != 0; }

  void set_on_stack(const bool value);

  // Faster than MetaspaceObj::is_shared() - used by set_on_stack()

  bool is_shared() const                     { return (_flags & _is_shared) != 0; }

  bool has_dynamic_constant() const       { return (_flags & _has_dynamic_constant) != 0; }

  void set_has_dynamic_constant()         { _flags |= _has_dynamic_constant; }

  // Klass holding pool

  InstanceKlass* pool_holder() const      { return _pool_holder; }

  void set_pool_holder(InstanceKlass* k)  { _pool_holder = k; }

  InstanceKlass** pool_holder_addr()      { return &_pool_holder; }

  // Interpreter runtime support

  ConstantPoolCache* cache() const        { return _cache; }

  void set_cache(ConstantPoolCache* cache){ _cache = cache; }

  virtual void metaspace_pointers_do(MetaspaceClosure* iter);

  virtual MetaspaceObj::Type type() const { return ConstantPoolType; }

  // Create object cache in the constant pool

  void initialize_resolved_references(ClassLoaderData* loader_data,

                                      const intStack& reference_map,

                                      int constant_pool_map_length,

                                      TRAPS);

  // resolved strings, methodHandles and callsite objects from the constant pool

  objArrayOop resolved_references()  const;

  objArrayOop resolved_references_or_null()  const;

  // mapping resolved object array indexes to cp indexes and back.

  int object_to_cp_index(int index)         { return reference_map()->at(index); }

  int cp_to_object_index(int index);

  void set_resolved_klasses(Array<Klass*>* rk)  { _resolved_klasses = rk; }

  Array<Klass*>* resolved_klasses() const       { return _resolved_klasses; }

  void allocate_resolved_klasses(ClassLoaderData* loader_data, int num_klasses, TRAPS);

  void initialize_unresolved_klasses(ClassLoaderData* loader_data, TRAPS);

  // Invokedynamic indexes.

  // They must look completely different from normal indexes.

  // The main reason is that byte swapping is sometimes done on normal indexes.

  // Finally, it is helpful for debugging to tell the two apart.

  static bool is_invokedynamic_index(int i) { return (i < 0); }

  static int  decode_invokedynamic_index(int i) { assert(is_invokedynamic_index(i),  ""); return ~i; }

  static int  encode_invokedynamic_index(int i) { assert(!is_invokedynamic_index(i), ""); return ~i; }

  // The invokedynamic points at a CP cache entry.  This entry points back

  // at the original CP entry (CONSTANT_InvokeDynamic) and also (via f2) at an entry

  // in the resolved_references array (which provides the appendix argument).

  int invokedynamic_cp_cache_index(int index) const {

    assert (is_invokedynamic_index(index), "should be a invokedynamic index");

    int cache_index = decode_invokedynamic_index(index);

    return cache_index;

  }

  ConstantPoolCacheEntry* invokedynamic_cp_cache_entry_at(int index) const {

    // decode index that invokedynamic points to.

    int cp_cache_index = invokedynamic_cp_cache_index(index);

    return cache()->entry_at(cp_cache_index);

  }

  // Assembly code support

  static int tags_offset_in_bytes()         { return offset_of(ConstantPool, _tags); }

  static int cache_offset_in_bytes()        { return offset_of(ConstantPool, _cache); }

  static int pool_holder_offset_in_bytes()  { return offset_of(ConstantPool, _pool_holder); }

  static int resolved_klasses_offset_in_bytes()    { return offset_of(ConstantPool, _resolved_klasses); }

  // Storing constants

  // For temporary use while constructing constant pool

  void klass_index_at_put(int which, int name_index) {

    tag_at_put(which, JVM_CONSTANT_ClassIndex);

    *int_at_addr(which) = name_index;

  }

  // Unsafe anonymous class support:

  void klass_at_put(int class_index, int name_index, int resolved_klass_index, Klass* k, Symbol* name);

  void klass_at_put(int class_index, Klass* k);

  void unresolved_klass_at_put(int which, int name_index, int resolved_klass_index) {

    release_tag_at_put(which, JVM_CONSTANT_UnresolvedClass);

    assert((name_index & 0xffff0000) == 0, "must be");

    assert((resolved_klass_index & 0xffff0000) == 0, "must be");

    *int_at_addr(which) =

      build_int_from_shorts((jushort)resolved_klass_index, (jushort)name_index);

  }

  void method_handle_index_at_put(int which, int ref_kind, int ref_index) {

    tag_at_put(which, JVM_CONSTANT_MethodHandle);

    *int_at_addr(which) = ((jint) ref_index<<16) | ref_kind;

  }

  void method_type_index_at_put(int which, int ref_index) {

    tag_at_put(which, JVM_CONSTANT_MethodType);

    *int_at_addr(which) = ref_index;

  }

  void dynamic_constant_at_put(int which, int bootstrap_specifier_index, int name_and_type_index) {

    tag_at_put(which, JVM_CONSTANT_Dynamic);

    *int_at_addr(which) = ((jint) name_and_type_index<<16) | bootstrap_specifier_index;

  }

  void invoke_dynamic_at_put(int which, int bootstrap_specifier_index, int name_and_type_index) {

    tag_at_put(which, JVM_CONSTANT_InvokeDynamic);

    *int_at_addr(which) = ((jint) name_and_type_index<<16) | bootstrap_specifier_index;

  }

  void unresolved_string_at_put(int which, Symbol* s) {

    release_tag_at_put(which, JVM_CONSTANT_String);

    slot_at_put(which, CPSlot(s));

  }

  void int_at_put(int which, jint i) {

    tag_at_put(which, JVM_CONSTANT_Integer);

    *int_at_addr(which) = i;

  }

  void long_at_put(int which, jlong l) {

    tag_at_put(which, JVM_CONSTANT_Long);

    // *long_at_addr(which) = l;

    Bytes::put_native_u8((address)long_at_addr(which), *((u8*) &l));

  }

  void float_at_put(int which, jfloat f) {

    tag_at_put(which, JVM_CONSTANT_Float);

    *float_at_addr(which) = f;

  }

  void double_at_put(int which, jdouble d) {

    tag_at_put(which, JVM_CONSTANT_Double);

    // *double_at_addr(which) = d;

    // u8 temp = *(u8*) &d;

    Bytes::put_native_u8((address) double_at_addr(which), *((u8*) &d));

  }

  Symbol** symbol_at_addr(int which) const {

    assert(is_within_bounds(which), "index out of bounds");

    return (Symbol**) &base()[which];

  }

  void symbol_at_put(int which, Symbol* s) {

    assert(s->refcount() != 0, "should have nonzero refcount");

    tag_at_put(which, JVM_CONSTANT_Utf8);

    *symbol_at_addr(which) = s;

  }

  void string_at_put(int which, int obj_index, oop str);

  // For temporary use while constructing constant pool

  void string_index_at_put(int which, int string_index) {

    tag_at_put(which, JVM_CONSTANT_StringIndex);

    *int_at_addr(which) = string_index;

  }

  void field_at_put(int which, int class_index, int name_and_type_index) {

    tag_at_put(which, JVM_CONSTANT_Fieldref);

    *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index;

  }

  void method_at_put(int which, int class_index, int name_and_type_index) {

    tag_at_put(which, JVM_CONSTANT_Methodref);

    *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index;

  }

  void interface_method_at_put(int which, int class_index, int name_and_type_index) {

    tag_at_put(which, JVM_CONSTANT_InterfaceMethodref);

    *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index;  // Not so nice

  }

  void name_and_type_at_put(int which, int name_index, int signature_index) {

    tag_at_put(which, JVM_CONSTANT_NameAndType);

    *int_at_addr(which) = ((jint) signature_index<<16) | name_index;  // Not so nice

  }

  // Tag query

  constantTag tag_at(int which) const;

  // Fetching constants

  Klass* klass_at(int which, TRAPS) {

    constantPoolHandle h_this(THREAD, this);

    return klass_at_impl(h_this, which, true, THREAD);

  }

  // Version of klass_at that doesn't save the resolution error, called during deopt

  Klass* klass_at_ignore_error(int which, TRAPS) {

    constantPoolHandle h_this(THREAD, this);

    return klass_at_impl(h_this, which, false, THREAD);

  }

  CPKlassSlot klass_slot_at(int which) const {

    assert(tag_at(which).is_unresolved_klass() || tag_at(which).is_klass(),

           "Corrupted constant pool");

    int value = *int_at_addr(which);

    int name_index = extract_high_short_from_int(value);

    int resolved_klass_index = extract_low_short_from_int(value);

    return CPKlassSlot(name_index, resolved_klass_index);

  }

  Symbol* klass_name_at(int which) const;  // Returns the name, w/o resolving.

  int klass_name_index_at(int which) const {

    return klass_slot_at(which).name_index();

  }

  Klass* resolved_klass_at(int which) const;  // Used by Compiler

  // RedefineClasses() API support:

  Symbol* klass_at_noresolve(int which) { return klass_name_at(which); }

  void temp_unresolved_klass_at_put(int which, int name_index) {

    // Used only during constant pool merging for class redefinition. The resolved klass index

    // will be initialized later by a call to initialize_unresolved_klasses().

    unresolved_klass_at_put(which, name_index, CPKlassSlot::_temp_resolved_klass_index);

  }

  jint int_at(int which) {

    assert(tag_at(which).is_int(), "Corrupted constant pool");

    return *int_at_addr(which);

  }

  jlong long_at(int which) {

    assert(tag_at(which).is_long(), "Corrupted constant pool");

    // return *long_at_addr(which);

    u8 tmp = Bytes::get_native_u8((address)&base()[which]);

    return *((jlong*)&tmp);

  }

  jfloat float_at(int which) {

    assert(tag_at(which).is_float(), "Corrupted constant pool");

    return *float_at_addr(which);

  }

  jdouble double_at(int which) {

    assert(tag_at(which).is_double(), "Corrupted constant pool");

    u8 tmp = Bytes::get_native_u8((address)&base()[which]);

    return *((jdouble*)&tmp);

  }

  Symbol* symbol_at(int which) const {

    assert(tag_at(which).is_utf8(), "Corrupted constant pool");

    return *symbol_at_addr(which);

  }

  oop string_at(int which, int obj_index, TRAPS) {

    constantPoolHandle h_this(THREAD, this);

    return string_at_impl(h_this, which, obj_index, THREAD);

  }

  oop string_at(int which, TRAPS) {

    int obj_index = cp_to_object_index(which);

    return string_at(which, obj_index, THREAD);

  }

  // Version that can be used before string oop array is created.

  oop uncached_string_at(int which, TRAPS);

  // A "pseudo-string" is an non-string oop that has found its way into

  // a String entry.

  // This can happen if the user patches a live

  // object into a CONSTANT_String entry of an unsafe anonymous class.

  // Method oops internally created for method handles may also

  // use pseudo-strings to link themselves to related metaobjects.

  bool is_pseudo_string_at(int which);

  oop pseudo_string_at(int which, int obj_index);

  oop pseudo_string_at(int which);

  void pseudo_string_at_put(int which, int obj_index, oop x) {

    assert(tag_at(which).is_string(), "Corrupted constant pool");

    Symbol* sym = unresolved_string_at(which);

    slot_at_put(which, CPSlot(sym, CPSlot::_pseudo_bit));

    string_at_put(which, obj_index, x);    // this works just fine

  }

  // only called when we are sure a string entry is already resolved (via an

  // earlier string_at call.

  oop resolved_string_at(int which) {

    assert(tag_at(which).is_string(), "Corrupted constant pool");

    // Must do an acquire here in case another thread resolved the klass

    // behind our back, lest we later load stale values thru the oop.

    // we might want a volatile_obj_at in ObjArrayKlass.

    int obj_index = cp_to_object_index(which);

    return resolved_references()->obj_at(obj_index);

  }

  Symbol* unresolved_string_at(int which) {

    assert(tag_at(which).is_string(), "Corrupted constant pool");

    Symbol* sym = slot_at(which).get_symbol();

    return sym;

  }

  // Returns an UTF8 for a CONSTANT_String entry at a given index.

  // UTF8 char* representation was chosen to avoid conversion of

  // java_lang_Strings at resolved entries into Symbol*s

  // or vice versa.