/*

 * Copyright (c) 1997, 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_OOPS_CONSTANTPOOLOOP_HPP

#define SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP

#include "oops/arrayOop.hpp"

#include "oops/cpCache.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayOop.hpp"

#include "runtime/handles.hpp"

#include "utilities/constantTag.hpp"

#ifdef TARGET_ARCH_x86

# include "bytes_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "bytes_sparc.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "bytes_zero.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "bytes_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "bytes_ppc.hpp"

#endif

// 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 VALUE_OBJ_CLASS_SPEC {

  intptr_t _ptr;

 public:

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

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

  CPSlot(Symbol* ptr): _ptr((intptr_t)ptr | 1) {}

  intptr_t value()   { return _ptr; }

  bool is_resolved()   { return (_ptr & 1) == 0; }

  bool is_unresolved() { return (_ptr & 1) == 1; }

  Symbol* get_symbol() {

    assert(is_unresolved(), "bad call");

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

  }

  Klass* get_klass() {

    assert(is_resolved(), "bad call");

    return (Klass*)_ptr;

  }

};

class ConstantPool : public Metadata {

  friend class VMStructs;

  friend class BytecodeInterpreter;  // Directly extracts an oop in the pool for fast instanceof/checkcast

  friend class Universe;             // For null constructor

 private:

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

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

  Klass*               _pool_holder; // the corresponding class

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

  // Array of resolved objects from the constant pool and map from resolved

  // object index to original constant pool index

  jobject              _resolved_references;

  Array<u2>*           _reference_map;

  int                  _flags;         // a few header bits to describe contents for GC

  int                  _length; // number of elements in the array

  bool                 _on_stack;     // Redefined method still executing refers to this constant pool.

  union {

    // set for CDS to restore resolved references

    int                _resolved_reference_length;

  // only set to non-zero if constant pool is merged by RedefineClasses

  int                  _orig_length;

  } _saved;

  Monitor*             _lock;

  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)  { tags()->release_at_put(which, t); }

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

  enum FlagBit {

    FB_has_invokedynamic = 1,

    FB_has_pseudo_string = 2,

    FB_has_preresolution = 3

  };

  int flags() const                         { return _flags; }

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

  bool flag_at(FlagBit fb) const            { return (_flags & (1 << (int)fb)) != 0; }

  void set_flag_at(FlagBit fb);

  // no clear_flag_at function; they only increase

 private:

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

  CPSlot slot_at(int which) {

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

    // Uses volatile because the klass slot changes without a lock.

    volatile intptr_t adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which));

    assert(adr != 0 || which == 0, "cp entry for klass should not be zero");

    return CPSlot(adr);

  }

  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_raw(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_pseudo_string() const            { return flag_at(FB_has_pseudo_string); }

  bool has_invokedynamic() const            { return flag_at(FB_has_invokedynamic); }

  bool has_preresolution() const            { return flag_at(FB_has_preresolution); }

  void set_pseudo_string()                  {    set_flag_at(FB_has_pseudo_string); }

  void set_invokedynamic()                  {    set_flag_at(FB_has_invokedynamic); }

  void set_preresolution()                  {    set_flag_at(FB_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 _on_stack; }

  void set_on_stack(const bool value);

  // Klass holding pool

  Klass* pool_holder() const              { return _pool_holder; }

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

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

  // Interpreter runtime support

  ConstantPoolCache* cache() const        { return _cache; }

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

  // Create object cache in the constant pool

  void initialize_resolved_references(ClassLoaderData* loader_data,

                                      intStack reference_map,

                                      int constant_pool_map_length,

                                      TRAPS);

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

  objArrayOop resolved_references()  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);

  // 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_references_offset_in_bytes() { return offset_of(ConstantPool, _resolved_references); }

  static int reference_map_offset_in_bytes() { return offset_of(ConstantPool, _reference_map); }

  // Storing constants

  void klass_at_put(int which, Klass* k) {

    assert(k != NULL, "resolved class shouldn't be null");

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

    OrderAccess::release_store_ptr((Klass* volatile *)obj_at_addr_raw(which), k);

    // The interpreter assumes when the tag is stored, the klass is resolved

    // and the Klass* is a klass rather than a Symbol*, so we need

    // hardware store ordering here.

    release_tag_at_put(which, JVM_CONSTANT_Class);

  }

  // 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;

  }

  // Temporary until actual use

  void unresolved_klass_at_put(int which, Symbol* s) {

    release_tag_at_put(which, JVM_CONSTANT_UnresolvedClass);

    slot_at_put(which, s);

  }

  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 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);

    *symbol_at_addr(which) = 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) {

    resolved_references()->obj_at_put(obj_index, str);

  }

  void set_object_tag_at(int which) {

    release_tag_at_put(which, JVM_CONSTANT_Object);

    }

  void object_at_put(int which, oop obj) {

    resolved_references()->obj_at_put(cp_to_object_index(which), obj);

  }

  // 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 { return (constantTag)tags()->at_acquire(which); }

  // Fetching constants

  Klass* klass_at(int which, TRAPS) {

    constantPoolHandle h_this(THREAD, this);

    return klass_at_impl(h_this, which, CHECK_NULL);

  }

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

  Klass* resolved_klass_at(int which) {  // Used by Compiler

    guarantee(tag_at(which).is_klass(), "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.

    return CPSlot((Klass*)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_klass();

  }

  // This method should only be used with a cpool lock or during parsing or gc

  Symbol* unresolved_klass_at(int which) {     // Temporary until actual use

    Symbol* s = CPSlot((Symbol*)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol();

    // check that the klass is still unresolved.

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

    return s;

  }

  // RedefineClasses() API support:

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

  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) {

    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);

  oop object_at(int which) {

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

    int obj_index = cp_to_object_index(which);

    return resolved_references()->obj_at(obj_index);

  }

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

  // a String entry.

  // Under EnableInvokeDynamic this can happen if the user patches a live

  // object into a CONSTANT_String entry of an 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) {

    // A pseudo string is a string that doesn't have a symbol in the cpSlot

    return unresolved_string_at(which) == NULL;

  }

  oop pseudo_string_at(int which, int obj_index) {

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

    assert(unresolved_string_at(which) == NULL, "shouldn't have symbol");

    oop s = resolved_references()->obj_at(obj_index);

    return s;

  }

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

    assert(EnableInvokeDynamic, "");

    set_pseudo_string();        // mark header

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

    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* s = *symbol_at_addr(which);

    return s;

  }

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

  // Caller is responsible for checking for pseudo-strings.

  char* string_at_noresolve(int which);

  jint name_and_type_at(int which) {

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

    return *int_at_addr(which);

  }

  int method_handle_ref_kind_at(int which) {

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

    return extract_low_short_from_int(*int_at_addr(which));  // mask out unwanted ref_index bits

  }

  int method_handle_index_at(int which) {