/*

 * Copyright (c) 1999, 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 "asm/macroAssembler.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compileLog.hpp"

#include "oops/objArrayKlass.hpp"

#include "opto/addnode.hpp"

#include "opto/callGenerator.hpp"

#include "opto/castnode.hpp"

#include "opto/cfgnode.hpp"

#include "opto/convertnode.hpp"

#include "opto/countbitsnode.hpp"

#include "opto/intrinsicnode.hpp"

#include "opto/idealKit.hpp"

#include "opto/mathexactnode.hpp"

#include "opto/movenode.hpp"

#include "opto/mulnode.hpp"

#include "opto/narrowptrnode.hpp"

#include "opto/opaquenode.hpp"

#include "opto/parse.hpp"

#include "opto/runtime.hpp"

#include "opto/subnode.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/sharedRuntime.hpp"

#include "trace/traceMacros.hpp"

class LibraryIntrinsic : public InlineCallGenerator {

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

 public:

 private:

  bool             _is_virtual;

  bool             _does_virtual_dispatch;

  int8_t           _predicates_count;  // Intrinsic is predicated by several conditions

  int8_t           _last_predicate; // Last generated predicate

  vmIntrinsics::ID _intrinsic_id;

 public:

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

    : InlineCallGenerator(m),

      _is_virtual(is_virtual),

      _does_virtual_dispatch(does_virtual_dispatch),

      _predicates_count((int8_t)predicates_count),

      _last_predicate((int8_t)-1),

      _intrinsic_id(id)

  {

  }

  virtual bool is_intrinsic() const { return true; }

  virtual bool is_virtual()   const { return _is_virtual; }

  virtual bool is_predicated() const { return _predicates_count > 0; }

  virtual int  predicates_count() const { return _predicates_count; }

  virtual bool does_virtual_dispatch()   const { return _does_virtual_dispatch; }

  virtual JVMState* generate(JVMState* jvms);

  virtual Node* generate_predicate(JVMState* jvms, int predicate);

  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

  Node*             _result;        // the result node, if any

  int               _reexecute_sp;  // the stack pointer when bytecode needs to be reexecuted

  const TypeOopPtr* sharpen_unsafe_type(Compile::AliasType* alias_type, const TypePtr *adr_type, bool is_native_ptr = false);

 public:

  LibraryCallKit(JVMState* jvms, LibraryIntrinsic* intrinsic)

    : GraphKit(jvms),

      _intrinsic(intrinsic),

      _result(NULL)

  {

    // Check if this is a root compile.  In that case we don't have a caller.

    if (!jvms->has_method()) {

      _reexecute_sp = sp();

    } else {

      // Find out how many arguments the interpreter needs when deoptimizing

      // and save the stack pointer value so it can used by uncommon_trap.

      // We find the argument count by looking at the declared signature.

      bool ignored_will_link;

      ciSignature* declared_signature = NULL;

      ciMethod* ignored_callee = caller()->get_method_at_bci(bci(), ignored_will_link, &declared_signature);

      const int nargs = declared_signature->arg_size_for_bc(caller()->java_code_at_bci(bci()));

      _reexecute_sp = sp() + nargs;  // "push" arguments back on stack

    }

  }

  virtual LibraryCallKit* is_LibraryCallKit() const { return (LibraryCallKit*)this; }

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

  bool  try_to_inline(int predicate);

  Node* try_to_predicate(int predicate);

  void push_result() {

    // Push the result onto the stack.

    if (!stopped() && result() != NULL) {

      BasicType bt = result()->bottom_type()->basic_type();

      push_node(bt, result());

    }

  }

 private:

  void fatal_unexpected_iid(vmIntrinsics::ID iid) {

    fatal(err_msg_res("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid)));

  }

  void  set_result(Node* n) { assert(_result == NULL, "only set once"); _result = n; }

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

  Node*     result() { return _result; }

  virtual int reexecute_sp() { return _reexecute_sp; }

  // Helper functions to inline natives

  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_limit_guard(Node* offset, Node* subseq_length,

                             Node* array_length,

                             RegionNode* region);

  Node* generate_current_thread(Node* &tls_output);

  Node* load_mirror_from_klass(Node* klass);

  Node* load_klass_from_mirror_common(Node* mirror, bool never_see_null,

                                      RegionNode* region, int null_path,

                                      int offset);

  Node* load_klass_from_mirror(Node* mirror, bool never_see_null,

                               RegionNode* region, int null_path) {

    int offset = java_lang_Class::klass_offset_in_bytes();

    return load_klass_from_mirror_common(mirror, never_see_null,

                                         region, null_path,

                                         offset);

  }

  Node* load_array_klass_from_mirror(Node* mirror, bool never_see_null,

                                     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,

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

  }

  Node * load_field_from_object(Node * fromObj, const char * fieldName, const char * fieldTypeString, bool is_exact, bool is_static);

  Node* make_string_method_node(int opcode, Node* str1_start, Node* cnt1, Node* str2_start, Node* cnt2);

  Node* make_string_method_node(int opcode, Node* str1, Node* str2);

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

  bool inline_string_equals();

  Node* round_double_node(Node* n);

  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_math(vmIntrinsics::ID id);

  template <typename OverflowOp>

  bool inline_math_overflow(Node* arg1, Node* arg2);

  void inline_math_mathExact(Node* math, Node* test);

  bool inline_math_addExactI(bool is_increment);

  bool inline_math_addExactL(bool is_increment);

  bool inline_math_multiplyExactI();

  bool inline_math_multiplyExactL();

  bool inline_math_negateExactI();

  bool inline_math_negateExactL();

  bool inline_math_subtractExactI(bool is_decrement);

  bool inline_math_subtractExactL(bool is_decrement);

  bool inline_exp();

  bool inline_pow();

  Node* finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName);

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

  // Helper for inline_unsafe_access.

  // Generates the guards that check whether the result of

  // Unsafe.getObject should be recorded in an SATB log buffer.

  void insert_pre_barrier(Node* base_oop, Node* offset, Node* pre_val, bool need_mem_bar);

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

  static bool klass_needs_init_guard(Node* kls);

  bool inline_unsafe_allocate();

  bool inline_unsafe_copyMemory();

  bool inline_native_currentThread();

#ifdef TRACE_HAVE_INTRINSICS

  bool inline_native_classID();

  bool inline_native_threadID();

#endif

  bool inline_native_time_funcs(address method, const char* funcName);

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

  void copy_to_clone(Node* obj, Node* alloc_obj, Node* obj_size, bool is_array, bool card_mark);

  bool inline_native_clone(bool is_virtual);

  bool inline_native_Reflection_getCallerClass();

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

  AllocateArrayNode* tightly_coupled_allocation(Node* ptr,

                                                RegionNode* slow_region);

  typedef enum { LS_xadd, LS_xchg, LS_cmpxchg } LoadStoreKind;

  bool inline_unsafe_load_store(BasicType type,  LoadStoreKind kind);

  bool inline_unsafe_ordered_store(BasicType type);

  bool inline_unsafe_fence(vmIntrinsics::ID id);

  bool inline_fp_conversions(vmIntrinsics::ID id);

  bool inline_number_methods(vmIntrinsics::ID id);

  bool inline_reference_get();

  bool inline_Class_cast();

  bool inline_aescrypt_Block(vmIntrinsics::ID id);

  bool inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id);

  Node* inline_cipherBlockChaining_AESCrypt_predicate(bool decrypting);

  Node* get_key_start_from_aescrypt_object(Node* aescrypt_object);

  Node* get_original_key_start_from_aescrypt_object(Node* aescrypt_object);

  bool inline_sha_implCompress(vmIntrinsics::ID id);

  bool inline_digestBase_implCompressMB(int predicate);

  bool inline_sha_implCompressMB(Node* digestBaseObj, ciInstanceKlass* instklass_SHA,

                                 bool long_state, address stubAddr, const char *stubName,

                                 Node* src_start, Node* ofs, Node* limit);

  Node* get_state_from_sha_object(Node *sha_object);

  Node* get_state_from_sha5_object(Node *sha_object);

  Node* inline_digestBase_implCompressMB_predicate(int predicate);

  bool inline_encodeISOArray();

  bool inline_updateCRC32();

  bool inline_updateBytesCRC32();

  bool inline_updateByteBufferCRC32();

  bool inline_multiplyToLen();

  bool inline_profileBoolean();

};

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

  ccstr disable_intr = NULL;

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

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

      (method_has_option_value("DisableIntrinsic", disable_intr)

       && strstr(disable_intr, 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::_equals:

    case vmIntrinsics::_equalsC:

    case vmIntrinsics::_getAndAddInt:

    case vmIntrinsics::_getAndAddLong:

    case vmIntrinsics::_getAndSetInt:

    case vmIntrinsics::_getAndSetLong:

    case vmIntrinsics::_getAndSetObject:

    case vmIntrinsics::_loadFence:

    case vmIntrinsics::_storeFence:

    case vmIntrinsics::_fullFence:

      break;  // InlineNatives does not control String.compareTo

    case vmIntrinsics::_Reference_get:

      break;  // InlineNatives does not control Reference.get

    default:

      return NULL;

    }

  }

  int predicates = 0;

  bool does_virtual_dispatch = false;

  switch (id) {

  case vmIntrinsics::_compareTo:

    if (!SpecialStringCompareTo)  return NULL;

    if (!Matcher::match_rule_supported(Op_StrComp))  return NULL;

    break;

  case vmIntrinsics::_indexOf:

    if (!SpecialStringIndexOf)  return NULL;

    break;

  case vmIntrinsics::_equals:

    if (!SpecialStringEquals)  return NULL;

    if (!Matcher::match_rule_supported(Op_StrEquals))  return NULL;

    break;

  case vmIntrinsics::_equalsC:

    if (!SpecialArraysEquals)  return NULL;

    if (!Matcher::match_rule_supported(Op_AryEq))  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;

    does_virtual_dispatch = true;

    break;

  case vmIntrinsics::_clone:

    does_virtual_dispatch = true;

  case vmIntrinsics::_copyOf:

  case vmIntrinsics::_copyOfRange:

    if (!InlineObjectCopy)  return NULL;

    // These also use the arraycopy intrinsic mechanism:

    if (!InlineArrayCopy)  return NULL;

    break;

  case vmIntrinsics::_encodeISOArray:

    if (!SpecialEncodeISOArray)  return NULL;

    if (!Matcher::match_rule_supported(Op_EncodeISOArray))  return NULL;

    break;

  case vmIntrinsics::_checkIndex:

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

    return NULL;

  case vmIntrinsics::_getCallerClass:

    if (!InlineReflectionGetCallerClass)  return NULL;

    if (SystemDictionary::reflect_CallerSensitive_klass() == NULL)  return NULL;

    break;

  case vmIntrinsics::_bitCount_i:

    if (!Matcher::match_rule_supported(Op_PopCountI)) return NULL;

    break;

  case vmIntrinsics::_bitCount_l:

    if (!Matcher::match_rule_supported(Op_PopCountL)) return NULL;

    break;

  case vmIntrinsics::_numberOfLeadingZeros_i:

    if (!Matcher::match_rule_supported(Op_CountLeadingZerosI)) return NULL;

    break;

  case vmIntrinsics::_numberOfLeadingZeros_l:

    if (!Matcher::match_rule_supported(Op_CountLeadingZerosL)) return NULL;

    break;

  case vmIntrinsics::_numberOfTrailingZeros_i:

    if (!Matcher::match_rule_supported(Op_CountTrailingZerosI)) return NULL;

    break;

  case vmIntrinsics::_numberOfTrailingZeros_l:

    if (!Matcher::match_rule_supported(Op_CountTrailingZerosL)) return NULL;

    break;

  case vmIntrinsics::_reverseBytes_c:

    if (!Matcher::match_rule_supported(Op_ReverseBytesUS)) return NULL;

    break;

  case vmIntrinsics::_reverseBytes_s:

    if (!Matcher::match_rule_supported(Op_ReverseBytesS))  return NULL;

    break;

  case vmIntrinsics::_reverseBytes_i:

    if (!Matcher::match_rule_supported(Op_ReverseBytesI))  return NULL;

    break;

  case vmIntrinsics::_reverseBytes_l:

    if (!Matcher::match_rule_supported(Op_ReverseBytesL))  return NULL;

    break;

  case vmIntrinsics::_Reference_get:

    // Use the intrinsic version of Reference.get() so that the value in

    // the referent field can be registered by the G1 pre-barrier code.

    // Also add memory barrier to prevent commoning reads from this field

    // across safepoint since GC can change it value.

    break;

  case vmIntrinsics::_compareAndSwapObject:

#ifdef _LP64

    if (!UseCompressedOops && !Matcher::match_rule_supported(Op_CompareAndSwapP)) return NULL;

#endif

    break;

  case vmIntrinsics::_compareAndSwapLong:

    if (!Matcher::match_rule_supported(Op_CompareAndSwapL)) return NULL;

    break;

  case vmIntrinsics::_getAndAddInt:

    if (!Matcher::match_rule_supported(Op_GetAndAddI)) return NULL;

    break;

  case vmIntrinsics::_getAndAddLong:

    if (!Matcher::match_rule_supported(Op_GetAndAddL)) return NULL;

    break;

  case vmIntrinsics::_getAndSetInt:

    if (!Matcher::match_rule_supported(Op_GetAndSetI)) return NULL;

    break;

  case vmIntrinsics::_getAndSetLong:

    if (!Matcher::match_rule_supported(Op_GetAndSetL)) return NULL;

    break;

  case vmIntrinsics::_getAndSetObject:

#ifdef _LP64

    if (!UseCompressedOops && !Matcher::match_rule_supported(Op_GetAndSetP)) return NULL;

    if (UseCompressedOops && !Matcher::match_rule_supported(Op_GetAndSetN)) return NULL;

    break;

#else

    if (!Matcher::match_rule_supported(Op_GetAndSetP)) return NULL;

    break;

#endif

  case vmIntrinsics::_aescrypt_encryptBlock:

  case vmIntrinsics::_aescrypt_decryptBlock:

    if (!UseAESIntrinsics) return NULL;

    break;

  case vmIntrinsics::_multiplyToLen:

    if (!UseMultiplyToLenIntrinsic) return NULL;

    break;

  case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:

  case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:

    if (!UseAESIntrinsics) return NULL;

    // these two require the predicated logic

    predicates = 1;

    break;

  case vmIntrinsics::_sha_implCompress:

    if (!UseSHA1Intrinsics) return NULL;