/*

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

 *

 */

#include "precompiled.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/debugInfo.hpp"

#include "code/pcDesc.hpp"

#include "interpreter/interpreter.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/klass.hpp"

#include "oops/klassOop.hpp"

#include "oops/methodOop.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayOop.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/safepoint.hpp"

#include "runtime/vframe.hpp"

#include "utilities/preserveException.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "thread_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "thread_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "thread_windows.inline.hpp"

#endif

static bool find_field(instanceKlass* ik,

                       Symbol* name_symbol, Symbol* signature_symbol,

                       fieldDescriptor* fd,

                       bool allow_super = false) {

  if (allow_super)

    return ik->find_field(name_symbol, signature_symbol, fd) != NULL;

  else

    return ik->find_local_field(name_symbol, signature_symbol, fd);

}

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

static void

compute_offset(int &dest_offset,

               klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol,

               bool allow_super = false) {

  fieldDescriptor fd;

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

  if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {

    ResourceMark rm;

    tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string());

    fatal("Invalid layout of preloaded class");

  }

  dest_offset = fd.offset();

}

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

static void

compute_optional_offset(int& dest_offset,

                        klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol,

                        bool allow_super = false) {

  fieldDescriptor fd;

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

  if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {

    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, JavaObjectsInPerm, 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(Symbol* 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, os::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");

    HandleMark hm(thread);

    ThreadToNativeFromVM ttn(thread);

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

  }

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

}

// Converts a Java String to a native C string that can be used for

// native OS calls.

char* java_lang_String::as_platform_dependent_str(Handle java_string, TRAPS) {

  typedef char* (*to_platform_string_fn_t)(JNIEnv*, jstring, bool*);

  static to_platform_string_fn_t _to_platform_string_fn = NULL;

  if (_to_platform_string_fn == NULL) {

    void *lib_handle = os::native_java_library();

    _to_platform_string_fn = CAST_TO_FN_PTR(to_platform_string_fn_t, os::dll_lookup(lib_handle, "GetStringPlatformChars"));

    if (_to_platform_string_fn == NULL) {

      fatal("GetStringPlatformChars missing");

    }

  }

  char *native_platform_string;

  { JavaThread* thread = (JavaThread*)THREAD;

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

    JNIEnv *env = thread->jni_environment();

    jstring js = (jstring) JNIHandles::make_local(env, java_string());

    bool is_copy;

    HandleMark hm(thread);

    ThreadToNativeFromVM ttn(thread);

    native_platform_string = (_to_platform_string_fn)(env, js, &is_copy);

    assert(is_copy == JNI_TRUE, "is_copy value changed");

    JNIHandles::destroy_local(js);

  }

  return native_platform_string;

}

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;

}

unsigned int java_lang_String::hash_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);

  if (length == 0) return 0;

  return hash_string(value->char_at_addr(offset), length);

}

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

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

  Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);

  return sym;

}

Symbol* java_lang_String::as_symbol_or_null(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* base = (length == 0) ? NULL : value->char_at_addr(offset);

  return SymbolTable::probe_unicode(base, length);

}

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, char* buf, int buflen) {

  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, buf, buflen);

}

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("\"");

  }

}

static void initialize_static_field(fieldDescriptor* fd, TRAPS) {

  Handle mirror (THREAD, fd->field_holder()->java_mirror());

  assert(mirror.not_null() && fd->is_static(), "just checking");

  if (fd->has_initial_value()) {

    BasicType t = fd->field_type();

    switch (t) {

      case T_BYTE:

        mirror()->byte_field_put(fd->offset(), fd->int_initial_value());

              break;

      case T_BOOLEAN:

        mirror()->bool_field_put(fd->offset(), fd->int_initial_value());

              break;

      case T_CHAR:

        mirror()->char_field_put(fd->offset(), fd->int_initial_value());

              break;

      case T_SHORT:

        mirror()->short_field_put(fd->offset(), fd->int_initial_value());

              break;

      case T_INT:

        mirror()->int_field_put(fd->offset(), fd->int_initial_value());

        break;

      case T_FLOAT:

        mirror()->float_field_put(fd->offset(), fd->float_initial_value());

        break;

      case T_DOUBLE:

        mirror()->double_field_put(fd->offset(), fd->double_initial_value());

        break;

      case T_LONG:

        mirror()->long_field_put(fd->offset(), fd->long_initial_value());

        break;

      case T_OBJECT:

        {

          #ifdef ASSERT

          TempNewSymbol sym = SymbolTable::new_symbol("Ljava/lang/String;", CHECK);

          assert(fd->signature() == sym, "just checking");

          #endif

          oop string = fd->string_initial_value(CHECK);

          mirror()->obj_field_put(fd->offset(), string);

        }

        break;

      default:

        THROW_MSG(vmSymbols::java_lang_ClassFormatError(),

                  "Illegal ConstantValue attribute in class file");

    }

  }

}

// During bootstrap, java.lang.Class wasn't loaded so static field

// offsets were computed without the size added it.  Go back and

// update all the static field offsets to included the size.

static void fixup_static_field(fieldDescriptor* fd, TRAPS) {

  if (fd->is_static()) {

    int real_offset = fd->offset() + instanceMirrorKlass::offset_of_static_fields();

    typeArrayOop fields = instanceKlass::cast(fd->field_holder())->fields();

    fields->short_at_put(fd->index() + instanceKlass::low_offset,  extract_low_short_from_int(real_offset));

    fields->short_at_put(fd->index() + instanceKlass::high_offset, extract_high_short_from_int(real_offset));

  }

}

void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {

  assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");

  if (k->oop_is_instance()) {

    // Fixup the offsets

    instanceKlass::cast(k())->do_local_static_fields(&fixup_static_field, CHECK);

  }

  create_mirror(k, CHECK);

}

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() && (k->oop_is_instance() || k->oop_is_javaArray())) {

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

    Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);

    // Setup indirections

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

    k->set_java_mirror(mirror());

    instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());

    java_lang_Class::set_oop_size(mirror(), mk->instance_size(k));

    java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(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());

      }

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

      // Initialize static fields

      instanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);

    }

    return mirror();

  } else {

    return NULL;

  }

}

int  java_lang_Class::oop_size(oop java_class) {

  assert(oop_size_offset != 0, "must be set");

  return java_class->int_field(oop_size_offset);

}