5656 assert(!field->is_volatile(), "not defined for volatile fields");
5657
5658 if (is_static) {
5659 const TypeInstPtr* tip = TypeInstPtr::make(fromKls->java_mirror());
5660 fromObj = makecon(tip);
5661 }
5662
5663 // Next code copied from Parse::do_get_xxx():
5664
5665 // Compute address and memory type.
5666 int offset = field->offset_in_bytes();
5667 Node *adr = basic_plus_adr(fromObj, fromObj, offset);
5668
5669 return adr;
5670 }
5671
5672 //------------------------------inline_aescrypt_Block-----------------------
5673 bool LibraryCallKit::inline_aescrypt_Block(vmIntrinsics::ID id) {
5674 address stubAddr = NULL;
5675 const char *stubName;
5676 assert(UseAES, "need AES instruction support");
5677
5678 switch(id) {
5679 case vmIntrinsics::_aescrypt_encryptBlock:
5680 stubAddr = StubRoutines::aescrypt_encryptBlock();
5681 stubName = "aescrypt_encryptBlock";
5682 break;
5683 case vmIntrinsics::_aescrypt_decryptBlock:
5684 stubAddr = StubRoutines::aescrypt_decryptBlock();
5685 stubName = "aescrypt_decryptBlock";
5686 break;
5687 default:
5688 break;
5689 }
5690 if (stubAddr == NULL) return false;
5691
5692 Node* aescrypt_object = argument(0);
5693 Node* src = argument(1);
5694 Node* src_offset = argument(2);
5695 Node* dest = argument(3);
5696 Node* dest_offset = argument(4);
5725
5726 // Call the stub.
5727 make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::aescrypt_block_Type(),
5728 stubAddr, stubName, TypePtr::BOTTOM,
5729 src_start, dest_start, k_start, original_k_start);
5730 } else {
5731 // Call the stub.
5732 make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::aescrypt_block_Type(),
5733 stubAddr, stubName, TypePtr::BOTTOM,
5734 src_start, dest_start, k_start);
5735 }
5736
5737 return true;
5738 }
5739
5740 //------------------------------inline_cipherBlockChaining_AESCrypt-----------------------
5741 bool LibraryCallKit::inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id) {
5742 address stubAddr = NULL;
5743 const char *stubName = NULL;
5744
5745 assert(UseAES, "need AES instruction support");
5746
5747 switch(id) {
5748 case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
5749 stubAddr = StubRoutines::cipherBlockChaining_encryptAESCrypt();
5750 stubName = "cipherBlockChaining_encryptAESCrypt";
5751 break;
5752 case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
5753 stubAddr = StubRoutines::cipherBlockChaining_decryptAESCrypt();
5754 stubName = "cipherBlockChaining_decryptAESCrypt";
5755 break;
5756 default:
5757 break;
5758 }
5759 if (stubAddr == NULL) return false;
5760
5761 Node* cipherBlockChaining_object = argument(0);
5762 Node* src = argument(1);
5763 Node* src_offset = argument(2);
5764 Node* len = argument(3);
5765 Node* dest = argument(4);
5794 const TypeInstPtr* tinst = _gvn.type(cipherBlockChaining_object)->isa_instptr();
5795 assert(tinst != NULL, "CBC obj is null");
5796 assert(tinst->klass()->is_loaded(), "CBC obj is not loaded");
5797 ciKlass* klass_AESCrypt = tinst->klass()->as_instance_klass()->find_klass(ciSymbol::make("com/sun/crypto/provider/AESCrypt"));
5798 assert(klass_AESCrypt->is_loaded(), "predicate checks that this class is loaded");
5799
5800 ciInstanceKlass* instklass_AESCrypt = klass_AESCrypt->as_instance_klass();
5801 const TypeKlassPtr* aklass = TypeKlassPtr::make(instklass_AESCrypt);
5802 const TypeOopPtr* xtype = aklass->as_instance_type();
5803 Node* aescrypt_object = new CheckCastPPNode(control(), embeddedCipherObj, xtype);
5804 aescrypt_object = _gvn.transform(aescrypt_object);
5805
5806 // we need to get the start of the aescrypt_object's expanded key array
5807 Node* k_start = get_key_start_from_aescrypt_object(aescrypt_object);
5808 if (k_start == NULL) return false;
5809
5810 // similarly, get the start address of the r vector
5811 Node* objRvec = load_field_from_object(cipherBlockChaining_object, "r", "[B", /*is_exact*/ false);
5812 if (objRvec == NULL) return false;
5813 Node* r_start = array_element_address(objRvec, intcon(0), T_BYTE);
5814
5815 Node* cbcCrypt;
5816 if (Matcher::pass_original_key_for_aes()) {
5817 // on SPARC we need to pass the original key since key expansion needs to happen in intrinsics due to
5818 // compatibility issues between Java key expansion and SPARC crypto instructions
5819 Node* original_k_start = get_original_key_start_from_aescrypt_object(aescrypt_object);
5820 if (original_k_start == NULL) return false;
5821
5822 // Call the stub, passing src_start, dest_start, k_start, r_start, src_len and original_k_start
5823 cbcCrypt = make_runtime_call(RC_LEAF|RC_NO_FP,
5824 OptoRuntime::cipherBlockChaining_aescrypt_Type(),
5825 stubAddr, stubName, TypePtr::BOTTOM,
5826 src_start, dest_start, k_start, r_start, len, original_k_start);
5827 } else {
5828 // Call the stub, passing src_start, dest_start, k_start, r_start and src_len
5829 cbcCrypt = make_runtime_call(RC_LEAF|RC_NO_FP,
5830 OptoRuntime::cipherBlockChaining_aescrypt_Type(),
5831 stubAddr, stubName, TypePtr::BOTTOM,
5832 src_start, dest_start, k_start, r_start, len);
5833 }
|
5656 assert(!field->is_volatile(), "not defined for volatile fields");
5657
5658 if (is_static) {
5659 const TypeInstPtr* tip = TypeInstPtr::make(fromKls->java_mirror());
5660 fromObj = makecon(tip);
5661 }
5662
5663 // Next code copied from Parse::do_get_xxx():
5664
5665 // Compute address and memory type.
5666 int offset = field->offset_in_bytes();
5667 Node *adr = basic_plus_adr(fromObj, fromObj, offset);
5668
5669 return adr;
5670 }
5671
5672 //------------------------------inline_aescrypt_Block-----------------------
5673 bool LibraryCallKit::inline_aescrypt_Block(vmIntrinsics::ID id) {
5674 address stubAddr = NULL;
5675 const char *stubName;
5676 #ifdef AARCH32
5677 assert(UseAESIntrinsics, "sanity");
5678 #else
5679 assert(UseAES, "need AES instruction support");
5680 #endif
5681
5682 switch(id) {
5683 case vmIntrinsics::_aescrypt_encryptBlock:
5684 stubAddr = StubRoutines::aescrypt_encryptBlock();
5685 stubName = "aescrypt_encryptBlock";
5686 break;
5687 case vmIntrinsics::_aescrypt_decryptBlock:
5688 stubAddr = StubRoutines::aescrypt_decryptBlock();
5689 stubName = "aescrypt_decryptBlock";
5690 break;
5691 default:
5692 break;
5693 }
5694 if (stubAddr == NULL) return false;
5695
5696 Node* aescrypt_object = argument(0);
5697 Node* src = argument(1);
5698 Node* src_offset = argument(2);
5699 Node* dest = argument(3);
5700 Node* dest_offset = argument(4);
5729
5730 // Call the stub.
5731 make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::aescrypt_block_Type(),
5732 stubAddr, stubName, TypePtr::BOTTOM,
5733 src_start, dest_start, k_start, original_k_start);
5734 } else {
5735 // Call the stub.
5736 make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::aescrypt_block_Type(),
5737 stubAddr, stubName, TypePtr::BOTTOM,
5738 src_start, dest_start, k_start);
5739 }
5740
5741 return true;
5742 }
5743
5744 //------------------------------inline_cipherBlockChaining_AESCrypt-----------------------
5745 bool LibraryCallKit::inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id) {
5746 address stubAddr = NULL;
5747 const char *stubName = NULL;
5748
5749 #ifdef AARCH32
5750 assert(UseAESIntrinsics, "sanity");
5751 #else
5752 assert(UseAES, "need AES instruction support");
5753 #endif
5754
5755 switch(id) {
5756 case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
5757 stubAddr = StubRoutines::cipherBlockChaining_encryptAESCrypt();
5758 stubName = "cipherBlockChaining_encryptAESCrypt";
5759 break;
5760 case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
5761 stubAddr = StubRoutines::cipherBlockChaining_decryptAESCrypt();
5762 stubName = "cipherBlockChaining_decryptAESCrypt";
5763 break;
5764 default:
5765 break;
5766 }
5767 if (stubAddr == NULL) return false;
5768
5769 Node* cipherBlockChaining_object = argument(0);
5770 Node* src = argument(1);
5771 Node* src_offset = argument(2);
5772 Node* len = argument(3);
5773 Node* dest = argument(4);
5802 const TypeInstPtr* tinst = _gvn.type(cipherBlockChaining_object)->isa_instptr();
5803 assert(tinst != NULL, "CBC obj is null");
5804 assert(tinst->klass()->is_loaded(), "CBC obj is not loaded");
5805 ciKlass* klass_AESCrypt = tinst->klass()->as_instance_klass()->find_klass(ciSymbol::make("com/sun/crypto/provider/AESCrypt"));
5806 assert(klass_AESCrypt->is_loaded(), "predicate checks that this class is loaded");
5807
5808 ciInstanceKlass* instklass_AESCrypt = klass_AESCrypt->as_instance_klass();
5809 const TypeKlassPtr* aklass = TypeKlassPtr::make(instklass_AESCrypt);
5810 const TypeOopPtr* xtype = aklass->as_instance_type();
5811 Node* aescrypt_object = new CheckCastPPNode(control(), embeddedCipherObj, xtype);
5812 aescrypt_object = _gvn.transform(aescrypt_object);
5813
5814 // we need to get the start of the aescrypt_object's expanded key array
5815 Node* k_start = get_key_start_from_aescrypt_object(aescrypt_object);
5816 if (k_start == NULL) return false;
5817
5818 // similarly, get the start address of the r vector
5819 Node* objRvec = load_field_from_object(cipherBlockChaining_object, "r", "[B", /*is_exact*/ false);
5820 if (objRvec == NULL) return false;
5821 Node* r_start = array_element_address(objRvec, intcon(0), T_BYTE);
5822 #ifdef AARCH32
5823 if (r_start == NULL) return false;
5824 #endif
5825
5826 Node* cbcCrypt;
5827 if (Matcher::pass_original_key_for_aes()) {
5828 // on SPARC we need to pass the original key since key expansion needs to happen in intrinsics due to
5829 // compatibility issues between Java key expansion and SPARC crypto instructions
5830 Node* original_k_start = get_original_key_start_from_aescrypt_object(aescrypt_object);
5831 if (original_k_start == NULL) return false;
5832
5833 // Call the stub, passing src_start, dest_start, k_start, r_start, src_len and original_k_start
5834 cbcCrypt = make_runtime_call(RC_LEAF|RC_NO_FP,
5835 OptoRuntime::cipherBlockChaining_aescrypt_Type(),
5836 stubAddr, stubName, TypePtr::BOTTOM,
5837 src_start, dest_start, k_start, r_start, len, original_k_start);
5838 } else {
5839 // Call the stub, passing src_start, dest_start, k_start, r_start and src_len
5840 cbcCrypt = make_runtime_call(RC_LEAF|RC_NO_FP,
5841 OptoRuntime::cipherBlockChaining_aescrypt_Type(),
5842 stubAddr, stubName, TypePtr::BOTTOM,
5843 src_start, dest_start, k_start, r_start, len);
5844 }
|