src/share/vm/opto/library_call.cpp

rev 7792 : [mq]: 8081778-Use-Intel-x64-CPU-instructions-for-RSA-acceleration

*** 322,331 ****
--- 322,333 ----
    bool inline_encodeISOArray();
    bool inline_updateCRC32();
    bool inline_updateBytesCRC32();
    bool inline_updateByteBufferCRC32();
    bool inline_multiplyToLen();
+   bool inline_squareToLen();
+   bool inline_mulAdd();
  
    bool inline_profileBoolean();
  };
  
  
*** 525,534 ****
--- 527,544 ----
  
    case vmIntrinsics::_multiplyToLen:
      if (!UseMultiplyToLenIntrinsic) return NULL;
      break;
  
+   case vmIntrinsics::_squareToLen:
+     if (!UseSquareToLenIntrinsic) return NULL;
+     break;
+ 
+   case vmIntrinsics::_mulAdd:
+     if (!UseMulAddIntrinsic) return NULL;
+     break;
+ 
    case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
    case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
      if (!UseAESIntrinsics) return NULL;
      // these two require the predicated logic
      predicates = 1;
*** 925,934 ****
--- 935,950 ----
      return inline_digestBase_implCompressMB(predicate);
  
    case vmIntrinsics::_multiplyToLen:
      return inline_multiplyToLen();
  
+   case vmIntrinsics::_squareToLen:
+     return inline_squareToLen();
+ 
+   case vmIntrinsics::_mulAdd:
+     return inline_mulAdd();
+ 
    case vmIntrinsics::_encodeISOArray:
      return inline_encodeISOArray();
  
    case vmIntrinsics::_updateCRC32:
      return inline_updateCRC32();
*** 5854,5863 ****
--- 5870,5973 ----
    C->set_has_split_ifs(true); // Has chance for split-if optimization
    set_result(z);
    return true;
  }
  
+ //-------------inline_squareToLen------------------------------------
+ bool LibraryCallKit::inline_squareToLen() {
+   assert(UseSquareToLenIntrinsic, "not implementated on this platform");
+ 
+   address stubAddr = StubRoutines::squareToLen();
+   if (stubAddr == NULL) {
+     return false; // Intrinsic's stub is not implemented on this platform
+   }
+   const char* stubName = "squareToLen";
+ 
+   assert(callee()->signature()->size() == 4, "implSquareToLen has 4 parameters");
+ 
+   Node* x    = argument(0);
+   Node* len  = argument(1);
+   Node* z    = argument(2);
+   Node* zlen = argument(3);
+ 
+   const Type* x_type = x->Value(&_gvn);
+   const Type* z_type = z->Value(&_gvn);
+   const TypeAryPtr* top_x = x_type->isa_aryptr();
+   const TypeAryPtr* top_z = z_type->isa_aryptr();
+   if (top_x  == NULL || top_x->klass()  == NULL ||
+       top_z  == NULL || top_z->klass()  == NULL) {
+     // failed array check
+     return false;
+   }
+ 
+   BasicType x_elem = x_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type();
+   BasicType z_elem = z_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type();
+   if (x_elem != T_INT || z_elem != T_INT) {
+     return false;
+   }
+ 
+ 
+   Node* x_start = array_element_address(x, intcon(0), x_elem);
+   Node* z_start = array_element_address(z, intcon(0), z_elem);
+ 
+   Node*  call = make_runtime_call(RC_LEAF|RC_NO_FP,
+                                   OptoRuntime::squareToLen_Type(),
+                                   stubAddr, stubName, TypePtr::BOTTOM,
+                                   x_start, len, z_start, zlen);
+ 
+   set_result(z);
+   return true;
+ }
+ 
+ //-------------inline_mulAdd------------------------------------------
+ bool LibraryCallKit::inline_mulAdd() {
+   assert(UseMulAddIntrinsic, "not implementated on this platform");
+ 
+   address stubAddr = StubRoutines::mulAdd();
+   if (stubAddr == NULL) {
+     return false; // Intrinsic's stub is not implemented on this platform
+   }
+   const char* stubName = "mulAdd";
+ 
+   assert(callee()->signature()->size() == 5, "mulAdd has 5 parameters");
+ 
+   Node* out      = argument(0);
+   Node* in       = argument(1);
+   Node* offset   = argument(2);
+   Node* len      = argument(3);
+   Node* k        = argument(4);
+ 
+   const Type* out_type = out->Value(&_gvn);
+   const Type* in_type = in->Value(&_gvn);
+   const TypeAryPtr* top_out = out_type->isa_aryptr();
+   const TypeAryPtr* top_in = in_type->isa_aryptr();
+   if (top_out  == NULL || top_out->klass()  == NULL ||
+       top_in == NULL || top_in->klass() == NULL) {
+     // failed array check
+     return false;
+   }
+ 
+   BasicType out_elem = out_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type();
+   BasicType in_elem = in_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type();
+   if (out_elem != T_INT || in_elem != T_INT) {
+     return false;
+   }
+ 
+   Node* outlen = load_array_length(out);
+   Node* new_offset = _gvn.transform(new (C) SubINode(outlen, offset));
+   Node* out_start = array_element_address(out, intcon(0), out_elem);
+   Node* in_start = array_element_address(in, intcon(0), in_elem);
+ 
+   Node*  call = make_runtime_call(RC_LEAF|RC_NO_FP,
+                                   OptoRuntime::mulAdd_Type(),
+                                   stubAddr, stubName, TypePtr::BOTTOM,
+                                   out_start,in_start, new_offset, len, k);
+   Node* result = _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
+   set_result(result);
+   return true;
+ }
+ 
  
  /**
   * Calculate CRC32 for byte.
   * int java.util.zip.CRC32.update(int crc, int b)
   */