/*

 * Copyright 1999-2008 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/_library_call.cpp.incl"

class LibraryIntrinsic : public InlineCallGenerator {

  // Extend the set of intrinsics known to the runtime:

 public:

 private:

  bool             _is_virtual;

  vmIntrinsics::ID _intrinsic_id;

 public:

  LibraryIntrinsic(ciMethod* m, bool is_virtual, vmIntrinsics::ID id)

    : InlineCallGenerator(m),

      _is_virtual(is_virtual),

      _intrinsic_id(id)

  {

  }

  virtual bool is_intrinsic() const { return true; }

  virtual bool is_virtual()   const { return _is_virtual; }

  virtual JVMState* generate(JVMState* jvms);

  vmIntrinsics::ID intrinsic_id() const { return _intrinsic_id; }

};

// Local helper class for LibraryIntrinsic:

class LibraryCallKit : public GraphKit {

 private:

  LibraryIntrinsic* _intrinsic;   // the library intrinsic being called

 public:

  LibraryCallKit(JVMState* caller, LibraryIntrinsic* intrinsic)

    : GraphKit(caller),

      _intrinsic(intrinsic)

  {

  }

  ciMethod*         caller()    const    { return jvms()->method(); }

  int               bci()       const    { return jvms()->bci(); }

  LibraryIntrinsic* intrinsic() const    { return _intrinsic; }

  vmIntrinsics::ID  intrinsic_id() const { return _intrinsic->intrinsic_id(); }

  ciMethod*         callee()    const    { return _intrinsic->method(); }

  ciSignature*      signature() const    { return callee()->signature(); }

  int               arg_size()  const    { return callee()->arg_size(); }

  bool try_to_inline();

  // Helper functions to inline natives

  void push_result(RegionNode* region, PhiNode* value);

  Node* generate_guard(Node* test, RegionNode* region, float true_prob);

  Node* generate_slow_guard(Node* test, RegionNode* region);

  Node* generate_fair_guard(Node* test, RegionNode* region);

  Node* generate_negative_guard(Node* index, RegionNode* region,

                                // resulting CastII of index:

                                Node* *pos_index = NULL);

  Node* generate_nonpositive_guard(Node* index, bool never_negative,

                                   // resulting CastII of index:

                                   Node* *pos_index = NULL);

  Node* generate_limit_guard(Node* offset, Node* subseq_length,

                             Node* array_length,

                             RegionNode* region);

  Node* generate_current_thread(Node* &tls_output);

  address basictype2arraycopy(BasicType t, Node *src_offset, Node *dest_offset,

                              bool disjoint_bases, const char* &name);

  Node* load_mirror_from_klass(Node* klass);

  Node* load_klass_from_mirror_common(Node* mirror, bool never_see_null,

                                      int nargs,

                                      RegionNode* region, int null_path,

                                      int offset);

  Node* load_klass_from_mirror(Node* mirror, bool never_see_null, int nargs,

                               RegionNode* region, int null_path) {

    int offset = java_lang_Class::klass_offset_in_bytes();

    return load_klass_from_mirror_common(mirror, never_see_null, nargs,

                                         region, null_path,

                                         offset);

  }

  Node* load_array_klass_from_mirror(Node* mirror, bool never_see_null,

                                     int nargs,

                                     RegionNode* region, int null_path) {

    int offset = java_lang_Class::array_klass_offset_in_bytes();

    return load_klass_from_mirror_common(mirror, never_see_null, nargs,

                                         region, null_path,

                                         offset);

  }

  Node* generate_access_flags_guard(Node* kls,

                                    int modifier_mask, int modifier_bits,

                                    RegionNode* region);

  Node* generate_interface_guard(Node* kls, RegionNode* region);

  Node* generate_array_guard(Node* kls, RegionNode* region) {

    return generate_array_guard_common(kls, region, false, false);

  }

  Node* generate_non_array_guard(Node* kls, RegionNode* region) {

    return generate_array_guard_common(kls, region, false, true);

  }

  Node* generate_objArray_guard(Node* kls, RegionNode* region) {

    return generate_array_guard_common(kls, region, true, false);

  }

  Node* generate_non_objArray_guard(Node* kls, RegionNode* region) {

    return generate_array_guard_common(kls, region, true, true);

  }

  Node* generate_array_guard_common(Node* kls, RegionNode* region,

                                    bool obj_array, bool not_array);

  Node* generate_virtual_guard(Node* obj_klass, RegionNode* slow_region);

  CallJavaNode* generate_method_call(vmIntrinsics::ID method_id,

                                     bool is_virtual = false, bool is_static = false);

  CallJavaNode* generate_method_call_static(vmIntrinsics::ID method_id) {

    return generate_method_call(method_id, false, true);

  }

  CallJavaNode* generate_method_call_virtual(vmIntrinsics::ID method_id) {

    return generate_method_call(method_id, true, false);

  }

  bool inline_string_compareTo();

  bool inline_string_indexOf();

  Node* string_indexOf(Node* string_object, ciTypeArray* target_array, jint offset, jint cache_i, jint md2_i);

  Node* pop_math_arg();

  bool runtime_math(const TypeFunc* call_type, address funcAddr, const char* funcName);

  bool inline_math_native(vmIntrinsics::ID id);

  bool inline_trig(vmIntrinsics::ID id);

  bool inline_trans(vmIntrinsics::ID id);

  bool inline_abs(vmIntrinsics::ID id);

  bool inline_sqrt(vmIntrinsics::ID id);

  bool inline_pow(vmIntrinsics::ID id);

  bool inline_exp(vmIntrinsics::ID id);

  bool inline_min_max(vmIntrinsics::ID id);

  Node* generate_min_max(vmIntrinsics::ID id, Node* x, Node* y);

  // This returns Type::AnyPtr, RawPtr, or OopPtr.

  int classify_unsafe_addr(Node* &base, Node* &offset);

  Node* make_unsafe_address(Node* base, Node* offset);

  bool inline_unsafe_access(bool is_native_ptr, bool is_store, BasicType type, bool is_volatile);

  bool inline_unsafe_prefetch(bool is_native_ptr, bool is_store, bool is_static);

  bool inline_unsafe_allocate();

  bool inline_unsafe_copyMemory();

  bool inline_native_currentThread();

  bool inline_native_time_funcs(bool isNano);

  bool inline_native_isInterrupted();

  bool inline_native_Class_query(vmIntrinsics::ID id);

  bool inline_native_subtype_check();

  bool inline_native_newArray();

  bool inline_native_getLength();

  bool inline_array_copyOf(bool is_copyOfRange);

  bool inline_array_equals();

  bool inline_native_clone(bool is_virtual);

  bool inline_native_Reflection_getCallerClass();

  bool inline_native_AtomicLong_get();

  bool inline_native_AtomicLong_attemptUpdate();

  bool is_method_invoke_or_aux_frame(JVMState* jvms);

  // Helper function for inlining native object hash method

  bool inline_native_hashcode(bool is_virtual, bool is_static);

  bool inline_native_getClass();

  // Helper functions for inlining arraycopy

  bool inline_arraycopy();

  void generate_arraycopy(const TypePtr* adr_type,

                          BasicType basic_elem_type,

                          Node* src,  Node* src_offset,

                          Node* dest, Node* dest_offset,

                          Node* copy_length,

                          int nargs,  // arguments on stack for debug info

                          bool disjoint_bases = false,

                          bool length_never_negative = false,

                          RegionNode* slow_region = NULL);

  AllocateArrayNode* tightly_coupled_allocation(Node* ptr,

                                                RegionNode* slow_region);

  void generate_clear_array(const TypePtr* adr_type,

                            Node* dest,

                            BasicType basic_elem_type,

                            Node* slice_off,

                            Node* slice_len,

                            Node* slice_end);

  bool generate_block_arraycopy(const TypePtr* adr_type,

                                BasicType basic_elem_type,

                                AllocateNode* alloc,

                                Node* src,  Node* src_offset,

                                Node* dest, Node* dest_offset,

                                Node* dest_size);

  void generate_slow_arraycopy(const TypePtr* adr_type,

                               Node* src,  Node* src_offset,

                               Node* dest, Node* dest_offset,

                               Node* copy_length,

                               int nargs);

  Node* generate_checkcast_arraycopy(const TypePtr* adr_type,

                                     Node* dest_elem_klass,

                                     Node* src,  Node* src_offset,

                                     Node* dest, Node* dest_offset,

                                     Node* copy_length, int nargs);

  Node* generate_generic_arraycopy(const TypePtr* adr_type,

                                   Node* src,  Node* src_offset,

                                   Node* dest, Node* dest_offset,

                                   Node* copy_length, int nargs);

  void generate_unchecked_arraycopy(const TypePtr* adr_type,

                                    BasicType basic_elem_type,

                                    bool disjoint_bases,

                                    Node* src,  Node* src_offset,

                                    Node* dest, Node* dest_offset,

                                    Node* copy_length);

  bool inline_unsafe_CAS(BasicType type);

  bool inline_unsafe_ordered_store(BasicType type);

  bool inline_fp_conversions(vmIntrinsics::ID id);

  bool inline_reverseBytes(vmIntrinsics::ID id);

};

//---------------------------make_vm_intrinsic----------------------------

CallGenerator* Compile::make_vm_intrinsic(ciMethod* m, bool is_virtual) {

  vmIntrinsics::ID id = m->intrinsic_id();

  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");

  if (DisableIntrinsic[0] != '\0'

      && strstr(DisableIntrinsic, vmIntrinsics::name_at(id)) != NULL) {

    // disabled by a user request on the command line:

    // example: -XX:DisableIntrinsic=_hashCode,_getClass

    return NULL;

  }

  if (!m->is_loaded()) {

    // do not attempt to inline unloaded methods

    return NULL;

  }

  // Only a few intrinsics implement a virtual dispatch.

  // They are expensive calls which are also frequently overridden.

  if (is_virtual) {

    switch (id) {

    case vmIntrinsics::_hashCode:

    case vmIntrinsics::_clone:

      // OK, Object.hashCode and Object.clone intrinsics come in both flavors

      break;

    default:

      return NULL;

    }

  }

  // -XX:-InlineNatives disables nearly all intrinsics:

  if (!InlineNatives) {

    switch (id) {

    case vmIntrinsics::_indexOf:

    case vmIntrinsics::_compareTo:

    case vmIntrinsics::_equalsC:

      break;  // InlineNatives does not control String.compareTo

    default:

      return NULL;

    }

  }

  switch (id) {

  case vmIntrinsics::_compareTo:

    if (!SpecialStringCompareTo)  return NULL;

    break;

  case vmIntrinsics::_indexOf:

    if (!SpecialStringIndexOf)  return NULL;

    break;

  case vmIntrinsics::_equalsC:

    if (!SpecialArraysEquals)  return NULL;

    break;

  case vmIntrinsics::_arraycopy:

    if (!InlineArrayCopy)  return NULL;

    break;

  case vmIntrinsics::_copyMemory:

    if (StubRoutines::unsafe_arraycopy() == NULL)  return NULL;

    if (!InlineArrayCopy)  return NULL;

    break;

  case vmIntrinsics::_hashCode:

    if (!InlineObjectHash)  return NULL;

    break;

  case vmIntrinsics::_clone:

  case vmIntrinsics::_copyOf:

  case vmIntrinsics::_copyOfRange:

    if (!InlineObjectCopy)  return NULL;

    // These also use the arraycopy intrinsic mechanism:

    if (!InlineArrayCopy)  return NULL;

    break;

  case vmIntrinsics::_checkIndex:

    // We do not intrinsify this.  The optimizer does fine with it.

    return NULL;

  case vmIntrinsics::_get_AtomicLong:

  case vmIntrinsics::_attemptUpdate:

    if (!InlineAtomicLong)  return NULL;

    break;

  case vmIntrinsics::_Object_init:

  case vmIntrinsics::_invoke:

    // We do not intrinsify these; they are marked for other purposes.

    return NULL;

  case vmIntrinsics::_getCallerClass:

    if (!UseNewReflection)  return NULL;

    if (!InlineReflectionGetCallerClass)  return NULL;

    if (!JDK_Version::is_gte_jdk14x_version())  return NULL;

    break;

 default:

    break;

  }

  // -XX:-InlineClassNatives disables natives from the Class class.

  // The flag applies to all reflective calls, notably Array.newArray

  // (visible to Java programmers as Array.newInstance).

  if (m->holder()->name() == ciSymbol::java_lang_Class() ||

      m->holder()->name() == ciSymbol::java_lang_reflect_Array()) {

    if (!InlineClassNatives)  return NULL;

  }

  // -XX:-InlineThreadNatives disables natives from the Thread class.

  if (m->holder()->name() == ciSymbol::java_lang_Thread()) {

    if (!InlineThreadNatives)  return NULL;

  }

  // -XX:-InlineMathNatives disables natives from the Math,Float and Double classes.

  if (m->holder()->name() == ciSymbol::java_lang_Math() ||

      m->holder()->name() == ciSymbol::java_lang_Float() ||

      m->holder()->name() == ciSymbol::java_lang_Double()) {

    if (!InlineMathNatives)  return NULL;

  }

  // -XX:-InlineUnsafeOps disables natives from the Unsafe class.

  if (m->holder()->name() == ciSymbol::sun_misc_Unsafe()) {

    if (!InlineUnsafeOps)  return NULL;

  }

  return new LibraryIntrinsic(m, is_virtual, (vmIntrinsics::ID) id);

}

//----------------------register_library_intrinsics-----------------------

// Initialize this file's data structures, for each Compile instance.

void Compile::register_library_intrinsics() {

  // Nothing to do here.

}

JVMState* LibraryIntrinsic::generate(JVMState* jvms) {

  LibraryCallKit kit(jvms, this);

  Compile* C = kit.C;

  int nodes = C->unique();

#ifndef PRODUCT

  if ((PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) && Verbose) {

    char buf[1000];

    const char* str = vmIntrinsics::short_name_as_C_string(intrinsic_id(), buf, sizeof(buf));

    tty->print_cr("Intrinsic %s", str);

  }

#endif

  if (kit.try_to_inline()) {

    if (PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) {

      tty->print("Inlining intrinsic %s%s at bci:%d in",

                 vmIntrinsics::name_at(intrinsic_id()),

                 (is_virtual() ? " (virtual)" : ""), kit.bci());

      kit.caller()->print_short_name(tty);

      tty->print_cr(" (%d bytes)", kit.caller()->code_size());

    }

    C->gather_intrinsic_statistics(intrinsic_id(), is_virtual(), Compile::_intrinsic_worked);

    if (C->log()) {

      C->log()->elem("intrinsic id='%s'%s nodes='%d'",

                     vmIntrinsics::name_at(intrinsic_id()),

                     (is_virtual() ? " virtual='1'" : ""),

                     C->unique() - nodes);

    }

    return kit.transfer_exceptions_into_jvms();

  }

  if (PrintIntrinsics) {

    switch (intrinsic_id()) {

    case vmIntrinsics::_invoke:

    case vmIntrinsics::_Object_init:

      // We do not expect to inline these, so do not produce any noise about them.

      break;

    default:

      tty->print("Did not inline intrinsic %s%s at bci:%d in",

                 vmIntrinsics::name_at(intrinsic_id()),

                 (is_virtual() ? " (virtual)" : ""), kit.bci());

      kit.caller()->print_short_name(tty);

      tty->print_cr(" (%d bytes)", kit.caller()->code_size());

    }

  }

  C->gather_intrinsic_statistics(intrinsic_id(), is_virtual(), Compile::_intrinsic_failed);

  return NULL;

}

bool LibraryCallKit::try_to_inline() {

  // Handle symbolic names for otherwise undistinguished boolean switches:

  const bool is_store       = true;

  const bool is_native_ptr  = true;

  const bool is_static      = true;

  switch (intrinsic_id()) {

  case vmIntrinsics::_hashCode:

    return inline_native_hashcode(intrinsic()->is_virtual(), !is_static);

  case vmIntrinsics::_identityHashCode:

    return inline_native_hashcode(/*!virtual*/ false, is_static);

  case vmIntrinsics::_getClass:

    return inline_native_getClass();

  case vmIntrinsics::_dsin:

  case vmIntrinsics::_dcos:

  case vmIntrinsics::_dtan:

  case vmIntrinsics::_dabs:

  case vmIntrinsics::_datan2:

  case vmIntrinsics::_dsqrt:

  case vmIntrinsics::_dexp:

  case vmIntrinsics::_dlog:

  case vmIntrinsics::_dlog10:

  case vmIntrinsics::_dpow:

    return inline_math_native(intrinsic_id());

  case vmIntrinsics::_min:

  case vmIntrinsics::_max:

    return inline_min_max(intrinsic_id());

  case vmIntrinsics::_arraycopy:

    return inline_arraycopy();

  case vmIntrinsics::_compareTo:

    return inline_string_compareTo();

  case vmIntrinsics::_indexOf:

    return inline_string_indexOf();

  case vmIntrinsics::_getObject:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_OBJECT, false);

  case vmIntrinsics::_getBoolean:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_BOOLEAN, false);

  case vmIntrinsics::_getByte:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_BYTE, false);

  case vmIntrinsics::_getShort:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_SHORT, false);

  case vmIntrinsics::_getChar:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_CHAR, false);

  case vmIntrinsics::_getInt:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_INT, false);

  case vmIntrinsics::_getLong:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_LONG, false);

  case vmIntrinsics::_getFloat:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_FLOAT, false);

  case vmIntrinsics::_getDouble:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_DOUBLE, false);

  case vmIntrinsics::_putObject:

    return inline_unsafe_access(!is_native_ptr, is_store, T_OBJECT, false);

  case vmIntrinsics::_putBoolean:

    return inline_unsafe_access(!is_native_ptr, is_store, T_BOOLEAN, false);

  case vmIntrinsics::_putByte:

    return inline_unsafe_access(!is_native_ptr, is_store, T_BYTE, false);

  case vmIntrinsics::_putShort:

    return inline_unsafe_access(!is_native_ptr, is_store, T_SHORT, false);

  case vmIntrinsics::_putChar:

    return inline_unsafe_access(!is_native_ptr, is_store, T_CHAR, false);

  case vmIntrinsics::_putInt:

    return inline_unsafe_access(!is_native_ptr, is_store, T_INT, false);

  case vmIntrinsics::_putLong:

    return inline_unsafe_access(!is_native_ptr, is_store, T_LONG, false);

  case vmIntrinsics::_putFloat:

    return inline_unsafe_access(!is_native_ptr, is_store, T_FLOAT, false);

  case vmIntrinsics::_putDouble:

    return inline_unsafe_access(!is_native_ptr, is_store, T_DOUBLE, false);

  case vmIntrinsics::_getByte_raw:

    return inline_unsafe_access(is_native_ptr, !is_store, T_BYTE, false);

  case vmIntrinsics::_getShort_raw:

    return inline_unsafe_access(is_native_ptr, !is_store, T_SHORT, false);

  case vmIntrinsics::_getChar_raw:

    return inline_unsafe_access(is_native_ptr, !is_store, T_CHAR, false);

  case vmIntrinsics::_getInt_raw:

    return inline_unsafe_access(is_native_ptr, !is_store, T_INT, false);

  case vmIntrinsics::_getLong_raw:

    return inline_unsafe_access(is_native_ptr, !is_store, T_LONG, false);

  case vmIntrinsics::_getFloat_raw:

    return inline_unsafe_access(is_native_ptr, !is_store, T_FLOAT, false);

  case vmIntrinsics::_getDouble_raw:

    return inline_unsafe_access(is_native_ptr, !is_store, T_DOUBLE, false);

  case vmIntrinsics::_getAddress_raw:

    return inline_unsafe_access(is_native_ptr, !is_store, T_ADDRESS, false);

  case vmIntrinsics::_putByte_raw:

    return inline_unsafe_access(is_native_ptr, is_store, T_BYTE, false);

  case vmIntrinsics::_putShort_raw:

    return inline_unsafe_access(is_native_ptr, is_store, T_SHORT, false);

  case vmIntrinsics::_putChar_raw:

    return inline_unsafe_access(is_native_ptr, is_store, T_CHAR, false);

  case vmIntrinsics::_putInt_raw:

    return inline_unsafe_access(is_native_ptr, is_store, T_INT, false);

  case vmIntrinsics::_putLong_raw:

    return inline_unsafe_access(is_native_ptr, is_store, T_LONG, false);

  case vmIntrinsics::_putFloat_raw:

    return inline_unsafe_access(is_native_ptr, is_store, T_FLOAT, false);

  case vmIntrinsics::_putDouble_raw:

    return inline_unsafe_access(is_native_ptr, is_store, T_DOUBLE, false);

  case vmIntrinsics::_putAddress_raw:

    return inline_unsafe_access(is_native_ptr, is_store, T_ADDRESS, false);

  case vmIntrinsics::_getObjectVolatile:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_OBJECT, true);

  case vmIntrinsics::_getBooleanVolatile:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_BOOLEAN, true);

  case vmIntrinsics::_getByteVolatile:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_BYTE, true);

  case vmIntrinsics::_getShortVolatile:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_SHORT, true);

  case vmIntrinsics::_getCharVolatile:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_CHAR, true);

  case vmIntrinsics::_getIntVolatile:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_INT, true);

  case vmIntrinsics::_getLongVolatile:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_LONG, true);

  case vmIntrinsics::_getFloatVolatile:

    return inline_unsafe_access(!is_native_ptr, !is_store, T_FLOAT, true);

  case vmIntrinsics::_getDoubleVolatile: