/*

 * Copyright (c) 1997, 2015, 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.inline.hpp"

#include "classfile/stringTable.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/fieldStreams.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/klass.hpp"

#include "oops/method.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayOop.hpp"

#include "prims/jvmtiRedefineClassesTrace.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"

#if INCLUDE_JVMCI

#include "jvmci/jvmciJavaClasses.hpp"

#endif

#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 is_static = false, bool allow_super = false) {

  if (allow_super || is_static) {

    return ik->find_field(name_symbol, signature_symbol, is_static, 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, Symbol* name_symbol, Symbol* signature_symbol,

               bool is_static = false, bool allow_super = false) {

  fieldDescriptor fd;

  InstanceKlass* ik = InstanceKlass::cast(klass);

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

    ResourceMark rm;

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

#ifndef PRODUCT

    ik->print();

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

    for (AllFieldStream fs(ik); !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

    vm_exit_during_initialization("Invalid layout of preloaded class: use -XX:+TraceClassLoading to see the origin of the problem 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, Symbol* name_symbol, Symbol* signature_symbol,

                        bool allow_super = false) {

  fieldDescriptor fd;

  InstanceKlass* ik = InstanceKlass::cast(klass);

  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::hash_offset   = 0;

int java_lang_String::coder_offset  = 0;

bool java_lang_String::initialized  = false;

bool java_lang_String::is_instance(oop obj) {

  return is_instance_inlined(obj);

}

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::byte_array_signature());

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

  compute_optional_offset(coder_offset,  k, vmSymbols::coder_name(),  vmSymbols::byte_signature());

  initialized = true;

}

class CompactStringsFixup : public FieldClosure {

private:

  bool _value;

public:

  CompactStringsFixup(bool value) : _value(value) {}

  void do_field(fieldDescriptor* fd) {

    if (fd->name() == vmSymbols::compact_strings_name()) {

      oop mirror = fd->field_holder()->java_mirror();

      assert(fd->field_holder() == SystemDictionary::String_klass(), "Should be String");

      assert(mirror != NULL, "String must have mirror already");

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

    }

  }

};

void java_lang_String::set_compact_strings(bool value) {

  CompactStringsFixup fix(value);

  InstanceKlass::cast(SystemDictionary::String_klass())->do_local_static_fields(&fix);

}

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

  assert(initialized, "Must be initialized");

  assert(CompactStrings || !is_latin1, "Must be UTF16 without CompactStrings");

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

  int arr_length = is_latin1 ? length : length << 1; // 2 bytes per UTF16.

  typeArrayOop buffer = oopFactory::new_byteArray(arr_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

  set_coder(obj, is_latin1 ? CODER_LATIN1 : CODER_UTF16);

  return h_obj;

}

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

  bool is_latin1 = CompactStrings && UNICODE::is_latin1(unicode, length);

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

  typeArrayOop buffer = value(h_obj());

  assert(TypeArrayKlass::cast(buffer->klass())->element_type() == T_BYTE, "only byte[]");

  if (is_latin1) {

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

      buffer->byte_at_put(index, (jbyte)unicode[index]);

    }

  } else {

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

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

    }

  }

#ifdef ASSERT

  {

    ResourceMark rm;

    char* expected = UNICODE::as_utf8(unicode, length);

    char* actual = as_utf8_string(h_obj());

    if (strcmp(expected, actual) != 0) {

      tty->print_cr("Unicode conversion failure: %s --> %s", expected, actual);

      ShouldNotReachHere();

    }

  }

#endif

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

  }

  bool has_multibyte, is_latin1;

  int length = UTF8::unicode_length(utf8_str, is_latin1, has_multibyte);

  if (!CompactStrings) {

    has_multibyte = true;

    is_latin1 = false;

  }

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

  if (length > 0) {

    if (!has_multibyte) {

      strncpy((char*)value(h_obj())->byte_at_addr(0), utf8_str, length);

    } else if (is_latin1) {

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

    } else {

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

    }

  }

#ifdef ASSERT

  // This check is too strict because the input string is not necessarily valid UTF8.

  // For example, it may be created with arbitrary content via jni_NewStringUTF.

  /*

  {

    ResourceMark rm;

    const char* expected = utf8_str;

    char* actual = as_utf8_string(h_obj());

    if (strcmp(expected, actual) != 0) {

      tty->print_cr("String conversion failure: %s --> %s", expected, actual);

      ShouldNotReachHere();

    }

  }

  */

#endif

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

  const char* utf8_str = (char*)symbol->bytes();

  int utf8_len = symbol->utf8_length();

  bool has_multibyte, is_latin1;

  int length = UTF8::unicode_length(utf8_str, utf8_len, is_latin1, has_multibyte);

  if (!CompactStrings) {

    has_multibyte = true;

    is_latin1 = false;

  }

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

  if (length > 0) {

    if (!has_multibyte) {

      strncpy((char*)value(h_obj())->byte_at_addr(0), utf8_str, length);

    } else if (is_latin1) {

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

    } else {

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

    }

  }

#ifdef ASSERT

  {

    ResourceMark rm;

    const char* expected = symbol->as_utf8();

    char* actual = as_utf8_string(h_obj());

    if (strncmp(expected, actual, utf8_len) != 0) {

      tty->print_cr("Symbol conversion failure: %s --> %s", expected, actual);

      ShouldNotReachHere();

    }

  }

#endif

  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          length = java_lang_String::length(obj);

  bool      is_latin1 = java_lang_String::is_latin1(obj);

  // First check if any from_char exist

  int index; // Declared outside, used later

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

    jchar c = !is_latin1 ? value->char_at(index) :

                  ((jchar) value->byte_at(index)) & 0xff;

    if (c == from_char) {

      break;

    }

  }

  if (index == length) {

    // No from_char, so do not copy.

    return java_string;

  }

  // Check if result string will be latin1

  bool to_is_latin1 = false;

  // Replacement char must be latin1

  if (CompactStrings && UNICODE::is_latin1(to_char)) {

    if (is_latin1) {

      // Source string is latin1 as well

      to_is_latin1 = true;

    } else if (!UNICODE::is_latin1(from_char)) {

      // We are replacing an UTF16 char. Scan string to

      // check if result can be latin1 encoded.

      to_is_latin1 = true;

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

        jchar c = value->char_at(index);

        if (c != from_char && !UNICODE::is_latin1(c)) {

          to_is_latin1 = false;

          break;

        }

      }

    }

  }

  // Create new UNICODE (or byte) buffer. Must handlize value because GC

  // may happen during String and char array creation.

  typeArrayHandle h_value(THREAD, value);

  Handle string = basic_create(length, to_is_latin1, 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 = (!is_latin1) ? from_buffer->char_at(index) :

                    ((jchar) from_buffer->byte_at(index)) & 0xff;

    if (c == from_char) {

      c = to_char;

    }

    if (!to_is_latin1) {

      to_buffer->char_at_put(index, c);

    } else {

      to_buffer->byte_at_put(index, (jbyte) c);

    }

  }

  return string;

}

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

  typeArrayOop value  = java_lang_String::value(java_string);

               length = java_lang_String::length(java_string);

  bool      is_latin1 = java_lang_String::is_latin1(java_string);

  jchar* result = NEW_RESOURCE_ARRAY_RETURN_NULL(jchar, length);

  if (result != NULL) {

    if (!is_latin1) {

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

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

      }

    } else {

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

        result[index] = ((jchar) value->byte_at(index)) & 0xff;

      }

    }

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

  bool      is_latin1 = java_lang_String::is_latin1(java_string);

  if (is_latin1) {

    return java_lang_String::hash_code(value->byte_at_addr(0), length);

  } else {

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

  }

}

char* java_lang_String::as_quoted_ascii(oop java_string) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          length = java_lang_String::length(java_string);

  bool      is_latin1 = java_lang_String::is_latin1(java_string);

  if (length == 0) return NULL;