/*

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

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/debugInfo.hpp"

#include "code/pcDesc.hpp"

#include "compiler/compilerOracle.hpp"

#include "interpreter/interpreter.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/fieldStreams.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/klass.hpp"

#include "oops/method.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/thread.inline.hpp"

#include "runtime/vframe.hpp"

#include "utilities/preserveException.hpp"

#define INJECTED_FIELD_COMPUTE_OFFSET(klass, name, signature, may_be_java)    \

  klass::_##name##_offset = JavaClasses::compute_injected_offset(JavaClasses::klass##_##name##_enum);

#define DECLARE_INJECTED_FIELD(klass, name, signature, may_be_java)           \

  { SystemDictionary::WK_KLASS_ENUM_NAME(klass), vmSymbols::VM_SYMBOL_ENUM_NAME(name##_name), vmSymbols::VM_SYMBOL_ENUM_NAME(signature), may_be_java },

InjectedField JavaClasses::_injected_fields[] = {

  ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD)

};

int JavaClasses::compute_injected_offset(InjectedFieldID id) {

  return _injected_fields[id].compute_offset();

}

InjectedField* JavaClasses::get_injected(Symbol* class_name, int* field_count) {

  *field_count = 0;

  vmSymbols::SID sid = vmSymbols::find_sid(class_name);

  if (sid == vmSymbols::NO_SID) {

    // Only well known classes can inject fields

    return NULL;

  }

  int count = 0;

  int start = -1;

#define LOOKUP_INJECTED_FIELD(klass, name, signature, may_be_java) \

  if (sid == vmSymbols::VM_SYMBOL_ENUM_NAME(klass)) {              \

    count++;                                                       \

    if (start == -1) start = klass##_##name##_enum;                \

  }

  ALL_INJECTED_FIELDS(LOOKUP_INJECTED_FIELD);

#undef LOOKUP_INJECTED_FIELD

  if (start != -1) {

    *field_count = count;

    return _injected_fields + start;

  }

  return NULL;

}

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,

               Klass* 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());

#ifndef PRODUCT

    klass_oop->print();

    tty->print_cr("all fields:");

    for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) {

      tty->print_cr("  name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int());

    }

#endif //PRODUCT

    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,

                        Klass* 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();

  }

}

int java_lang_String::value_offset  = 0;

int java_lang_String::offset_offset = 0;

int java_lang_String::count_offset  = 0;

int java_lang_String::hash_offset   = 0;

bool java_lang_String::initialized  = false;

void java_lang_String::compute_offsets() {

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

  Klass* k = SystemDictionary::String_klass();

  compute_offset(value_offset,           k, vmSymbols::value_name(),  vmSymbols::char_array_signature());

  compute_optional_offset(offset_offset, k, vmSymbols::offset_name(), vmSymbols::int_signature());

  compute_optional_offset(count_offset,  k, vmSymbols::count_name(),  vmSymbols::int_signature());

  compute_optional_offset(hash_offset,   k, vmSymbols::hash_name(),   vmSymbols::int_signature());

  initialized = true;

}

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

  assert(initialized, "Must be initialized");

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

  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;

    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::create_from_unicode(jchar* unicode, int length, TRAPS) {

  Handle h_obj = basic_create(length, CHECK_NH);

  typeArrayOop buffer = value(h_obj());

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

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

  }

  return h_obj;

}

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

  Handle h_obj = create_from_unicode(unicode, length, 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, 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, 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, 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, TRAPS) {

  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_RETURN_NULL(jchar, length);

  if (result != NULL) {

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

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

    }

  } else {

    THROW_MSG_0(vmSymbols::java_lang_OutOfMemoryError(), "could not allocate Unicode string");

  }

  return result;

}

unsigned int java_lang_String::hash_code(oop java_string) {

  int          length = java_lang_String::length(java_string);

  // Zero length string will hash to zero with String.hashCode() function.

  if (length == 0) return 0;

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  return java_lang_String::hash_code(value->char_at_addr(offset), length);

}

char* java_lang_String::as_quoted_ascii(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);

  if (base == NULL) return NULL;

  int result_length = UNICODE::quoted_ascii_length(base, length) + 1;

  char* result = NEW_RESOURCE_ARRAY(char, result_length);

  UNICODE::as_quoted_ascii(base, length, result, result_length);

  assert(result_length >= length + 1, "must not be shorter");

  assert(result_length == (int)strlen(result) + 1, "must match");

  return result;

}

unsigned int java_lang_String::hash_string(oop java_string) {

  int          length = java_lang_String::length(java_string);

  // Zero length string doesn't hash necessarily hash to zero.

  if (length == 0) {

    return StringTable::hash_string(NULL, 0);

  }

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  return StringTable::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(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;

}

bool java_lang_String::equals(oop str1, oop str2) {

  assert(str1->klass() == SystemDictionary::String_klass(),

         "must be java String");

  assert(str2->klass() == SystemDictionary::String_klass(),

         "must be java String");

  typeArrayOop value1  = java_lang_String::value(str1);

  int          offset1 = java_lang_String::offset(str1);

  int          length1 = java_lang_String::length(str1);

  typeArrayOop value2  = java_lang_String::value(str2);

  int          offset2 = java_lang_String::offset(str2);

  int          length2 = java_lang_String::length(str2);

  if (length1 != length2) {

    return false;

  }

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

    if (value1->char_at(i + offset1) != value2->char_at(i + offset2)) {

      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;