/*

 * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_javaClasses.cpp.incl"

// Helpful macro for computing field offsets at run time rather than hardcoding them

#define COMPUTE_OFFSET(klass_name_as_C_str, dest_offset, klass_oop, name_symbol, signature_symbol) \

{                                                                                                  \

  fieldDescriptor fd;                                                                              \

  instanceKlass* ik = instanceKlass::cast(klass_oop);                                              \

  if (!ik->find_local_field(name_symbol, signature_symbol, &fd)) {                                 \

    fatal("Invalid layout of " klass_name_as_C_str);                                               \

  }                                                                                                \

  dest_offset = fd.offset();                                                                       \

}

// Same as above but for "optional" offsets that might not be present in certain JDK versions

#define COMPUTE_OPTIONAL_OFFSET(klass_name_as_C_str, dest_offset, klass_oop, name_symbol, signature_symbol) \

{                                                                                                  \

  fieldDescriptor fd;                                                                              \

  instanceKlass* ik = instanceKlass::cast(klass_oop);                                              \

  if (ik->find_local_field(name_symbol, signature_symbol, &fd)) {                                  \

    dest_offset = fd.offset();                                                                     \

  }                                                                                                \

}

Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) {

  // Create the String object first, so there's a chance that the String

  // and the char array it points to end up in the same cache line.

  oop obj;

  if (tenured) {

    obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH);

  } else {

    obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH);

  }

  // Create the char array.  The String object must be handlized here

  // because GC can happen as a result of the allocation attempt.

  Handle h_obj(THREAD, obj);

  typeArrayOop buffer;

  if (tenured) {

    buffer = oopFactory::new_permanent_charArray(length, CHECK_NH);

  } else {

    buffer = oopFactory::new_charArray(length, CHECK_NH);

  }

  // Point the String at the char array

  obj = h_obj();

  set_value(obj, buffer);

  // No need to zero the offset, allocation zero'ed the entire String object

  assert(offset(obj) == 0, "initial String offset should be zero");

//set_offset(obj, 0);

  set_count(obj, length);

  return h_obj;

}

Handle java_lang_String::basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS) {

  Handle h_obj = basic_create(length, tenured, CHECK_NH);

  typeArrayOop buffer = value(h_obj());

  for (int index = 0; index < length; index++) {

    buffer->char_at_put(index, unicode[index]);

  }

  return h_obj;

}

Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) {

  return basic_create_from_unicode(unicode, length, false, CHECK_NH);

}

Handle java_lang_String::create_tenured_from_unicode(jchar* unicode, int length, TRAPS) {

  return basic_create_from_unicode(unicode, length, true, CHECK_NH);

}

oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) {

  Handle h_obj = basic_create_from_unicode(unicode, length, false, CHECK_0);

  return h_obj();

}

Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {

  if (utf8_str == NULL) {

    return Handle();

  }

  int length = UTF8::unicode_length(utf8_str);

  Handle h_obj = basic_create(length, false, CHECK_NH);

  if (length > 0) {

    UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);

  }

  return h_obj;

}

oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {

  Handle h_obj = create_from_str(utf8_str, CHECK_0);

  return h_obj();

}

Handle java_lang_String::create_from_symbol(symbolHandle symbol, TRAPS) {

  int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());

  Handle h_obj = basic_create(length, false, CHECK_NH);

  if (length > 0) {

    UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length);

  }

  return h_obj;

}

// Converts a C string to a Java String based on current encoding

Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) {

  assert(str != NULL, "bad arguments");

  typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *);

  static to_java_string_fn_t _to_java_string_fn = NULL;

  if (_to_java_string_fn == NULL) {

    void *lib_handle = os::native_java_library();

    _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, hpi::dll_lookup(lib_handle, "NewStringPlatform"));

    if (_to_java_string_fn == NULL) {

      fatal("NewStringPlatform missing");

    }

  }

  jstring js = NULL;

  { JavaThread* thread = (JavaThread*)THREAD;

    assert(thread->is_Java_thread(), "must be java thread");

    ThreadToNativeFromVM ttn(thread);

    HandleMark hm(thread);

    js = (_to_java_string_fn)(thread->jni_environment(), str);

  }

  return Handle(THREAD, JNIHandles::resolve(js));

}

Handle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) {

  oop          obj    = java_string();

  // Typical usage is to convert all '/' to '.' in string.

  typeArrayOop value  = java_lang_String::value(obj);

  int          offset = java_lang_String::offset(obj);

  int          length = java_lang_String::length(obj);

  // First check if any from_char exist

  int index; // Declared outside, used later

  for (index = 0; index < length; index++) {

    if (value->char_at(index + offset) == from_char) {

      break;

    }

  }

  if (index == length) {

    // No from_char, so do not copy.

    return java_string;

  }

  // Create new UNICODE buffer. Must handlize value because GC

  // may happen during String and char array creation.

  typeArrayHandle h_value(THREAD, value);

  Handle string = basic_create(length, false, CHECK_NH);

  typeArrayOop from_buffer = h_value();

  typeArrayOop to_buffer   = java_lang_String::value(string());

  // Copy contents

  for (index = 0; index < length; index++) {

    jchar c = from_buffer->char_at(index + offset);

    if (c == from_char) {

      c = to_char;

    }

    to_buffer->char_at_put(index, c);

  }

  return string;

}

jchar* java_lang_String::as_unicode_string(oop java_string, int& length) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

               length = java_lang_String::length(java_string);

  jchar* result = NEW_RESOURCE_ARRAY(jchar, length);

  for (int index = 0; index < length; index++) {

    result[index] = value->char_at(index + offset);

  }

  return result;

}

symbolHandle java_lang_String::as_symbol(Handle java_string, TRAPS) {

  oop          obj    = java_string();

  typeArrayOop value  = java_lang_String::value(obj);

  int          offset = java_lang_String::offset(obj);

  int          length = java_lang_String::length(obj);

  ResourceMark rm(THREAD);

  symbolHandle result;

  if (length > 0) {

    int utf8_length = UNICODE::utf8_length(value->char_at_addr(offset), length);

    char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);

    UNICODE::convert_to_utf8(value->char_at_addr(offset), length, chars);

    // Allocate the symbol

    result = oopFactory::new_symbol_handle(chars, utf8_length, CHECK_(symbolHandle()));

  } else {

    result = oopFactory::new_symbol_handle("", 0, CHECK_(symbolHandle()));

  }

  return result;

}

int java_lang_String::utf8_length(oop java_string) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);

  return UNICODE::utf8_length(position, length);

}

char* java_lang_String::as_utf8_string(oop java_string) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);

  return UNICODE::as_utf8(position, length);

}

char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  assert(start + len <= length, "just checking");

  jchar* position = value->char_at_addr(offset + start);

  return UNICODE::as_utf8(position, len);

}

bool java_lang_String::equals(oop java_string, jchar* chars, int len) {

  assert(SharedSkipVerify ||

         java_string->klass() == SystemDictionary::string_klass(),

         "must be java_string");

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  if (length != len) {

    return false;

  }

  for (int i = 0; i < len; i++) {

    if (value->char_at(i + offset) != chars[i]) {

      return false;

    }

  }

  return true;

}

void java_lang_String::print(Handle java_string, outputStream* st) {

  oop          obj    = java_string();

  assert(obj->klass() == SystemDictionary::string_klass(), "must be java_string");

  typeArrayOop value  = java_lang_String::value(obj);

  int          offset = java_lang_String::offset(obj);

  int          length = java_lang_String::length(obj);

  int end = MIN2(length, 100);

  if (value == NULL) {

    // This can happen if, e.g., printing a String

    // object before its initializer has been called

    st->print_cr("NULL");

  } else {

    st->print("\"");

    for (int index = 0; index < length; index++) {

      st->print("%c", value->char_at(index + offset));

    }

    st->print("\"");

  }

}

oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {

  assert(k->java_mirror() == NULL, "should only assign mirror once");

  // Use this moment of initialization to cache modifier_flags also,

  // to support Class.getModifiers().  Instance classes recalculate

  // the cached flags after the class file is parsed, but before the

  // class is put into the system dictionary.

  int computed_modifiers = k->compute_modifier_flags(CHECK_0);

  k->set_modifier_flags(computed_modifiers);

  if (SystemDictionary::class_klass_loaded()) {

    // Allocate mirror (java.lang.Class instance)

    Handle mirror = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0);

    // Setup indirections

    mirror->obj_field_put(klass_offset,  k());

    k->set_java_mirror(mirror());

    // It might also have a component mirror.  This mirror must already exist.

    if (k->oop_is_javaArray()) {

      Handle comp_mirror;

      if (k->oop_is_typeArray()) {

        BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type();

        comp_mirror = Universe::java_mirror(type);

        assert(comp_mirror.not_null(), "must have primitive mirror");

      } else if (k->oop_is_objArray()) {

        klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass();

        if (element_klass != NULL

            && (Klass::cast(element_klass)->oop_is_instance() ||

                Klass::cast(element_klass)->oop_is_javaArray())) {

          comp_mirror = Klass::cast(element_klass)->java_mirror();

          assert(comp_mirror.not_null(), "must have element mirror");

        }

        // else some object array internal to the VM, like systemObjArrayKlassObj

      }

      if (comp_mirror.not_null()) {

        // Two-way link between the array klass and its component mirror:

        arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror());

        set_array_klass(comp_mirror(), k->as_klassOop());

      }

    }

    return mirror();

  } else {

    return NULL;

  }

}

oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {

  // This should be improved by adding a field at the Java level or by

  // introducing a new VM klass (see comment in ClassFileParser)

  oop java_class = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0);

  if (type != T_VOID) {

    klassOop aklass = Universe::typeArrayKlassObj(type);

    assert(aklass != NULL, "correct bootstrap");

    set_array_klass(java_class, aklass);

  }

  return java_class;

}

klassOop java_lang_Class::as_klassOop(oop java_class) {

  //%note memory_2

  klassOop k = klassOop(java_class->obj_field(klass_offset));

  assert(k == NULL || k->is_klass(), "type check");

  return k;

}

klassOop java_lang_Class::array_klass(oop java_class) {

  klassOop k = klassOop(java_class->obj_field(array_klass_offset));

  assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass");

  return k;

}

void java_lang_Class::set_array_klass(oop java_class, klassOop klass) {

  assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass");

  java_class->obj_field_put(array_klass_offset, klass);

}

methodOop java_lang_Class::resolved_constructor(oop java_class) {

  oop constructor = java_class->obj_field(resolved_constructor_offset);

  assert(constructor == NULL || constructor->is_method(), "should be method");

  return methodOop(constructor);

}

void java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) {

  assert(constructor->is_method(), "should be method");

  java_class->obj_field_put(resolved_constructor_offset, constructor);

}

bool java_lang_Class::is_primitive(oop java_class) {

  klassOop k = klassOop(java_class->obj_field(klass_offset));

  return k == NULL;

}

BasicType java_lang_Class::primitive_type(oop java_class) {

  assert(java_lang_Class::is_primitive(java_class), "just checking");

  klassOop ak = klassOop(java_class->obj_field(array_klass_offset));

  BasicType type = T_VOID;

  if (ak != NULL) {

    // Note: create_basic_type_mirror above initializes ak to a non-null value.

    type = arrayKlass::cast(ak)->element_type();

  } else {

    assert(java_class == Universe::void_mirror(), "only valid non-array primitive");

  }

  assert(Universe::java_mirror(type) == java_class, "must be consistent");

  return type;

}

oop java_lang_Class::primitive_mirror(BasicType t) {

  oop mirror = Universe::java_mirror(t);

  assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class");

  assert(java_lang_Class::is_primitive(mirror), "must be primitive");

  return mirror;

}

bool java_lang_Class::offsets_computed = false;

int  java_lang_Class::classRedefinedCount_offset = -1;

void java_lang_Class::compute_offsets() {

  assert(!offsets_computed, "offsets should be initialized only once");

  offsets_computed = true;

  klassOop k = SystemDictionary::class_klass();

  // The classRedefinedCount field is only present starting in 1.5,

  // so don't go fatal.

  COMPUTE_OPTIONAL_OFFSET("java.lang.Class", classRedefinedCount_offset,

    k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());

}

int java_lang_Class::classRedefinedCount(oop the_class_mirror) {

  if (!JDK_Version::is_gte_jdk15x_version()

      || classRedefinedCount_offset == -1) {

    // The classRedefinedCount field is only present starting in 1.5.

    // If we don't have an offset for it then just return -1 as a marker.

    return -1;

  }

  return the_class_mirror->int_field(classRedefinedCount_offset);

}

void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {

  if (!JDK_Version::is_gte_jdk15x_version()

      || classRedefinedCount_offset == -1) {

    // The classRedefinedCount field is only present starting in 1.5.

    // If we don't have an offset for it then nothing to set.

    return;

  }

  the_class_mirror->int_field_put(classRedefinedCount_offset, value);

}

// Note: JDK1.1 and before had a privateInfo_offset field which was used for the

//       platform thread structure, and a eetop offset which was used for thread

//       local storage (and unused by the HotSpot VM). In JDK1.2 the two structures

//       merged, so in the HotSpot VM we just use the eetop field for the thread

//       instead of the privateInfo_offset.

//

// Note: The stackSize field is only present starting in 1.4.

int java_lang_Thread::_name_offset = 0;

int java_lang_Thread::_group_offset = 0;

int java_lang_Thread::_contextClassLoader_offset = 0;

int java_lang_Thread::_inheritedAccessControlContext_offset = 0;

int java_lang_Thread::_priority_offset = 0;

int java_lang_Thread::_eetop_offset = 0;

int java_lang_Thread::_daemon_offset = 0;

int java_lang_Thread::_stillborn_offset = 0;

int java_lang_Thread::_stackSize_offset = 0;

int java_lang_Thread::_tid_offset = 0;

int java_lang_Thread::_thread_status_offset = 0;

int java_lang_Thread::_park_blocker_offset = 0;

int java_lang_Thread::_park_event_offset = 0 ;

void java_lang_Thread::compute_offsets() {

  assert(_group_offset == 0, "offsets should be initialized only once");

  klassOop k = SystemDictionary::thread_klass();

  COMPUTE_OFFSET("java.lang.Thread", _name_offset,      k, vmSymbols::name_name(),      vmSymbols::char_array_signature());

  COMPUTE_OFFSET("java.lang.Thread", _group_offset,     k, vmSymbols::group_name(),     vmSymbols::threadgroup_signature());

  COMPUTE_OFFSET("java.lang.Thread", _contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature());

  COMPUTE_OFFSET("java.lang.Thread", _inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());

  COMPUTE_OFFSET("java.lang.Thread", _priority_offset,  k, vmSymbols::priority_name(),  vmSymbols::int_signature());

  COMPUTE_OFFSET("java.lang.Thread", _daemon_offset,    k, vmSymbols::daemon_name(),    vmSymbols::bool_signature());

  COMPUTE_OFFSET("java.lang.Thread", _eetop_offset,     k, vmSymbols::eetop_name(),     vmSymbols::long_signature());

  COMPUTE_OFFSET("java.lang.Thread", _stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature());

  // The stackSize field is only present starting in 1.4, so don't go fatal.

  COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature());

  // The tid and thread_status fields are only present starting in 1.5, so don't go fatal.

  COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature());

  COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature());

  // The parkBlocker field is only present starting in 1.6, so don't go fatal.

  COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature());

  COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_event_offset, k, vmSymbols::park_event_name(),

 vmSymbols::long_signature());

}

JavaThread* java_lang_Thread::thread(oop java_thread) {

  return (JavaThread*) java_thread->obj_field(_eetop_offset);

}

void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {

  // We are storing a JavaThread* (malloc'ed data) into a long field in the thread

  // object. The store has to be 64-bit wide so we use a pointer store, but we

  // cannot call oopDesc::obj_field_put since it includes a write barrier!

  oop* addr = java_thread->obj_field_addr(_eetop_offset);

  *addr = (oop) thread;

}

typeArrayOop java_lang_Thread::name(oop java_thread) {

  oop name = java_thread->obj_field(_name_offset);

  assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");

  return typeArrayOop(name);

}

void java_lang_Thread::set_name(oop java_thread, typeArrayOop name) {

  assert(java_thread->obj_field(_name_offset) == NULL, "name should be NULL");

  java_thread->obj_field_put(_name_offset, name);

}

ThreadPriority java_lang_Thread::priority(oop java_thread) {

  return (ThreadPriority)java_thread->int_field(_priority_offset);

}

void java_lang_Thread::set_priority(oop java_thread, ThreadPriority priority) {

  java_thread->int_field_put(_priority_offset, priority);

}

oop java_lang_Thread::threadGroup(oop java_thread) {