/*

 * Copyright (c) 1997, 2011, 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/cpCacheOop.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayOop.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 and string types, the constant pool entry is

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

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

// the entry in the constant pool is a klass or String object and

// not a Symbol*.

class SymbolHashMap;

class CPSlot VALUE_OBJ_CLASS_SPEC {

  intptr_t _ptr;

 public:

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

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

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

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

  intptr_t value()   { return _ptr; }

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

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

  oop get_oop() {

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

    return oop(_ptr);

  }

  Symbol* get_symbol() {

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

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

  }

};

class constantPoolOopDesc : public oopDesc {

  friend class VMStructs;

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

 private:

  typeArrayOop         _tags; // the tag array describing the constant pool's contents

  constantPoolCacheOop _cache;         // the cache holding interpreter runtime information

  klassOop             _pool_holder;   // the corresponding class

  typeArrayOop         _operands;      // for variable-sized (InvokeDynamic) nodes, usually empty

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

  int                  _length; // number of elements in the array

  volatile bool        _is_conc_safe; // if true, safe for concurrent

                                      // GC processing

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

  int                  _orig_length;

  void set_tags(typeArrayOop tags)             { oop_store_without_check((oop*)&_tags, tags); }

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

  void release_tag_at_put(int which, jbyte t)  { tags()->release_byte_at_put(which, t); }

  void set_operands(typeArrayOop operands)     { oop_store_without_check((oop*)&_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(constantPoolOopDesc)); }

  oop* tags_addr()       { return (oop*)&_tags; }

  oop* cache_addr()      { return (oop*)&_cache; }

  oop* operands_addr()   { return (oop*)&_operands; }

  CPSlot slot_at(int which) {

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

    // There's a transitional value of zero when converting from

    // Symbol->0->Klass for G1 when resolving classes and strings.

    // wait for the value to be non-zero (this is temporary)

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

    if (adr == 0 && which != 0) {

      constantTag t = tag_at(which);

      if (t.is_unresolved_klass() || t.is_klass() ||

          t.is_unresolved_string() || t.is_string()) {

        while ((adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))) == 0);

      }

    }

    return CPSlot(adr);

  }

  void slot_at_put(int which, CPSlot s) const {

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

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

  }

  oop* obj_at_addr_raw(int which) const {

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

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

  }

  void obj_at_put_without_check(int which, oop o) {

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

    oop_store_without_check((volatile oop *)obj_at_addr_raw(which), o);

  }

  void obj_at_put(int which, oop o) const {

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

    oop_store((volatile oop*)obj_at_addr_raw(which), o);

  }

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

  }

 public:

  typeArrayOop tags() const                 { return _tags; }

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

  // Klass holding pool

  klassOop pool_holder() const              { return _pool_holder; }

  void set_pool_holder(klassOop k)          { oop_store_without_check((oop*)&_pool_holder, (oop) k); }

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

  // Interpreter runtime support

  constantPoolCacheOop cache() const        { return _cache; }

  void set_cache(constantPoolCacheOop cache){ oop_store((oop*)&_cache, cache); }

  // Assembly code support

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

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

  static int operands_offset_in_bytes()     { return offset_of(constantPoolOopDesc, _operands); }

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

  // Storing constants

  void klass_at_put(int which, klassOop k) {

    // Overwrite the old index with a GC friendly value so

    // that if G1 looks during the transition during oop_store it won't

    // assert the symbol is not an oop.

    *obj_at_addr_raw(which) = NULL;

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

    obj_at_put_without_check(which, k);

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

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

    // hardware store ordering here.

    release_tag_at_put(which, JVM_CONSTANT_Class);

    if (UseConcMarkSweepGC) {

      // In case the earlier card-mark was consumed by a concurrent

      // marking thread before the tag was updated, redirty the card.

      obj_at_put_without_check(which, k);

    }

  }

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

  }

  // Temporary until actual use

  void unresolved_string_at_put(int which, Symbol* s) {

    release_tag_at_put(which, JVM_CONSTANT_UnresolvedString);

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

    slot_at_put(which, s);

  }

  void string_at_put(int which, oop str) {

    // Overwrite the old index with a GC friendly value so

    // that if G1 looks during the transition during oop_store it won't

    // assert the symbol is not an oop.

    *obj_at_addr_raw(which) = NULL;

    assert(str != NULL, "resolved string shouldn't be null");

    obj_at_put(which, str);

    release_tag_at_put(which, JVM_CONSTANT_String);

    if (UseConcMarkSweepGC) {

      // In case the earlier card-mark was consumed by a concurrent

      // marking thread before the tag was updated, redirty the card.

      obj_at_put_without_check(which, str);

    }

  }

  void object_at_put(int which, oop str) {

    obj_at_put(which, str);

    release_tag_at_put(which, JVM_CONSTANT_Object);

    if (UseConcMarkSweepGC) {

      // In case the earlier card-mark was consumed by a concurrent

      // marking thread before the tag was updated, redirty the card.

      obj_at_put_without_check(which, 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 { return (constantTag)tags()->byte_at_acquire(which); }

  // Whether the entry is a pointer that must be GC'd.

  bool is_pointer_entry(int which) {

    constantTag tag = tag_at(which);

    return tag.is_klass() ||

      tag.is_string() ||

      tag.is_object();

  }

  // Whether the entry points to an object for ldc (resolved or not)

  bool is_object_entry(int which) {

    constantTag tag = tag_at(which);

    return is_pointer_entry(which) ||

      tag.is_unresolved_klass() ||

      tag.is_unresolved_string() ||

      tag.is_symbol();

  }

  // Fetching constants

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

  klassOop 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 klassOop(CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop());

  }

  // 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(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 slot_at(which).get_symbol();

  }

  oop string_at(int which, TRAPS) {

    constantPoolHandle h_this(THREAD, this);

    return string_at_impl(h_this, which, CHECK_NULL);

  }

  oop object_at(int which) {

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

    return slot_at(which).get_oop();

  }

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

  oop pseudo_string_at(int which) {

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

    return slot_at(which).get_oop();

  }

  void pseudo_string_at_put(int which, oop x) {

    assert(EnableInvokeDynamic, "");

    set_pseudo_string();        // mark header

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

    string_at_put(which, 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.

    return CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop();

  }

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

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

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

    // check that the string is still unresolved.

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

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

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

    return extract_high_short_from_int(*int_at_addr(which));  // shift out unwanted ref_kind bits

  }

  int method_type_index_at(int which) {

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

    return *int_at_addr(which);

  }

  // Derived queries:

  Symbol* method_handle_name_ref_at(int which) {

    int member = method_handle_index_at(which);

    return impl_name_ref_at(member, true);

  }

  Symbol* method_handle_signature_ref_at(int which) {

    int member = method_handle_index_at(which);

    return impl_signature_ref_at(member, true);

  }

  int method_handle_klass_index_at(int which) {

    int member = method_handle_index_at(which);

    return impl_klass_ref_index_at(member, true);

  }

  Symbol* method_type_signature_at(int which) {

    int sym = method_type_index_at(which);

    return symbol_at(sym);

  }