< prev index next >

src/hotspot/cpu/ppc/stubGenerator_ppc.cpp

Print this page
rev 56744 : 8233078: fix minimal VM build on Linux ppc64(le)


3086 
3087     // special/generic versions
3088     StubRoutines::_checkcast_arraycopy        = generate_checkcast_copy("checkcast_arraycopy", false);
3089     StubRoutines::_checkcast_arraycopy_uninit = generate_checkcast_copy("checkcast_arraycopy_uninit", true);
3090 
3091     StubRoutines::_unsafe_arraycopy  = generate_unsafe_copy("unsafe_arraycopy",
3092                                                             STUB_ENTRY(jbyte_arraycopy),
3093                                                             STUB_ENTRY(jshort_arraycopy),
3094                                                             STUB_ENTRY(jint_arraycopy),
3095                                                             STUB_ENTRY(jlong_arraycopy));
3096     StubRoutines::_generic_arraycopy = generate_generic_copy("generic_arraycopy",
3097                                                              STUB_ENTRY(jbyte_arraycopy),
3098                                                              STUB_ENTRY(jshort_arraycopy),
3099                                                              STUB_ENTRY(jint_arraycopy),
3100                                                              STUB_ENTRY(oop_arraycopy),
3101                                                              STUB_ENTRY(oop_disjoint_arraycopy),
3102                                                              STUB_ENTRY(jlong_arraycopy),
3103                                                              STUB_ENTRY(checkcast_arraycopy));
3104 
3105     // fill routines

3106     if (OptimizeFill) {
3107       StubRoutines::_jbyte_fill          = generate_fill(T_BYTE,  false, "jbyte_fill");
3108       StubRoutines::_jshort_fill         = generate_fill(T_SHORT, false, "jshort_fill");
3109       StubRoutines::_jint_fill           = generate_fill(T_INT,   false, "jint_fill");
3110       StubRoutines::_arrayof_jbyte_fill  = generate_fill(T_BYTE,  true, "arrayof_jbyte_fill");
3111       StubRoutines::_arrayof_jshort_fill = generate_fill(T_SHORT, true, "arrayof_jshort_fill");
3112       StubRoutines::_arrayof_jint_fill   = generate_fill(T_INT,   true, "arrayof_jint_fill");
3113     }

3114   }
3115 
3116   // Safefetch stubs.
3117   void generate_safefetch(const char* name, int size, address* entry, address* fault_pc, address* continuation_pc) {
3118     // safefetch signatures:
3119     //   int      SafeFetch32(int*      adr, int      errValue);
3120     //   intptr_t SafeFetchN (intptr_t* adr, intptr_t errValue);
3121     //
3122     // arguments:
3123     //   R3_ARG1 = adr
3124     //   R4_ARG2 = errValue
3125     //
3126     // result:
3127     //   R3_RET  = *adr or errValue
3128 
3129     StubCodeMark mark(this, "StubRoutines", name);
3130 
3131     // Entry point, pc or function descriptor.
3132     *entry = __ function_entry();
3133 


3562     StubRoutines::_throw_NullPointerException_at_call_entry= generate_throw_exception("NullPointerException at call throw_exception", CAST_FROM_FN_PTR(address, SharedRuntime::throw_NullPointerException_at_call), false);
3563 
3564     // support for verify_oop (must happen after universe_init)
3565     StubRoutines::_verify_oop_subroutine_entry             = generate_verify_oop();
3566 
3567     // arraycopy stubs used by compilers
3568     generate_arraycopy_stubs();
3569 
3570     // Safefetch stubs.
3571     generate_safefetch("SafeFetch32", sizeof(int),     &StubRoutines::_safefetch32_entry,
3572                                                        &StubRoutines::_safefetch32_fault_pc,
3573                                                        &StubRoutines::_safefetch32_continuation_pc);
3574     generate_safefetch("SafeFetchN", sizeof(intptr_t), &StubRoutines::_safefetchN_entry,
3575                                                        &StubRoutines::_safefetchN_fault_pc,
3576                                                        &StubRoutines::_safefetchN_continuation_pc);
3577 
3578 #ifdef COMPILER2
3579     if (UseMultiplyToLenIntrinsic) {
3580       StubRoutines::_multiplyToLen = generate_multiplyToLen();
3581     }
3582 #endif
3583 
3584     if (UseSquareToLenIntrinsic) {
3585       StubRoutines::_squareToLen = generate_squareToLen();
3586     }
3587     if (UseMulAddIntrinsic) {
3588       StubRoutines::_mulAdd = generate_mulAdd();
3589     }
3590     if (UseMontgomeryMultiplyIntrinsic) {
3591       StubRoutines::_montgomeryMultiply
3592         = CAST_FROM_FN_PTR(address, SharedRuntime::montgomery_multiply);
3593     }
3594     if (UseMontgomerySquareIntrinsic) {
3595       StubRoutines::_montgomerySquare
3596         = CAST_FROM_FN_PTR(address, SharedRuntime::montgomery_square);
3597     }

3598 
3599     if (UseAESIntrinsics) {
3600       StubRoutines::_aescrypt_encryptBlock = generate_aescrypt_encryptBlock();
3601       StubRoutines::_aescrypt_decryptBlock = generate_aescrypt_decryptBlock();
3602     }
3603 
3604     if (UseSHA256Intrinsics) {
3605       StubRoutines::_sha256_implCompress   = generate_sha256_implCompress(false, "sha256_implCompress");
3606       StubRoutines::_sha256_implCompressMB = generate_sha256_implCompress(true,  "sha256_implCompressMB");
3607     }
3608     if (UseSHA512Intrinsics) {
3609       StubRoutines::_sha512_implCompress   = generate_sha512_implCompress(false, "sha512_implCompress");
3610       StubRoutines::_sha512_implCompressMB = generate_sha512_implCompress(true, "sha512_implCompressMB");
3611     }
3612   }
3613 
3614  public:
3615   StubGenerator(CodeBuffer* code, bool all) : StubCodeGenerator(code) {
3616     // replace the standard masm with a special one:
3617     _masm = new MacroAssembler(code);


3086 
3087     // special/generic versions
3088     StubRoutines::_checkcast_arraycopy        = generate_checkcast_copy("checkcast_arraycopy", false);
3089     StubRoutines::_checkcast_arraycopy_uninit = generate_checkcast_copy("checkcast_arraycopy_uninit", true);
3090 
3091     StubRoutines::_unsafe_arraycopy  = generate_unsafe_copy("unsafe_arraycopy",
3092                                                             STUB_ENTRY(jbyte_arraycopy),
3093                                                             STUB_ENTRY(jshort_arraycopy),
3094                                                             STUB_ENTRY(jint_arraycopy),
3095                                                             STUB_ENTRY(jlong_arraycopy));
3096     StubRoutines::_generic_arraycopy = generate_generic_copy("generic_arraycopy",
3097                                                              STUB_ENTRY(jbyte_arraycopy),
3098                                                              STUB_ENTRY(jshort_arraycopy),
3099                                                              STUB_ENTRY(jint_arraycopy),
3100                                                              STUB_ENTRY(oop_arraycopy),
3101                                                              STUB_ENTRY(oop_disjoint_arraycopy),
3102                                                              STUB_ENTRY(jlong_arraycopy),
3103                                                              STUB_ENTRY(checkcast_arraycopy));
3104 
3105     // fill routines
3106 #ifdef COMPILER2
3107     if (OptimizeFill) {
3108       StubRoutines::_jbyte_fill          = generate_fill(T_BYTE,  false, "jbyte_fill");
3109       StubRoutines::_jshort_fill         = generate_fill(T_SHORT, false, "jshort_fill");
3110       StubRoutines::_jint_fill           = generate_fill(T_INT,   false, "jint_fill");
3111       StubRoutines::_arrayof_jbyte_fill  = generate_fill(T_BYTE,  true, "arrayof_jbyte_fill");
3112       StubRoutines::_arrayof_jshort_fill = generate_fill(T_SHORT, true, "arrayof_jshort_fill");
3113       StubRoutines::_arrayof_jint_fill   = generate_fill(T_INT,   true, "arrayof_jint_fill");
3114     }
3115 #endif
3116   }
3117 
3118   // Safefetch stubs.
3119   void generate_safefetch(const char* name, int size, address* entry, address* fault_pc, address* continuation_pc) {
3120     // safefetch signatures:
3121     //   int      SafeFetch32(int*      adr, int      errValue);
3122     //   intptr_t SafeFetchN (intptr_t* adr, intptr_t errValue);
3123     //
3124     // arguments:
3125     //   R3_ARG1 = adr
3126     //   R4_ARG2 = errValue
3127     //
3128     // result:
3129     //   R3_RET  = *adr or errValue
3130 
3131     StubCodeMark mark(this, "StubRoutines", name);
3132 
3133     // Entry point, pc or function descriptor.
3134     *entry = __ function_entry();
3135 


3564     StubRoutines::_throw_NullPointerException_at_call_entry= generate_throw_exception("NullPointerException at call throw_exception", CAST_FROM_FN_PTR(address, SharedRuntime::throw_NullPointerException_at_call), false);
3565 
3566     // support for verify_oop (must happen after universe_init)
3567     StubRoutines::_verify_oop_subroutine_entry             = generate_verify_oop();
3568 
3569     // arraycopy stubs used by compilers
3570     generate_arraycopy_stubs();
3571 
3572     // Safefetch stubs.
3573     generate_safefetch("SafeFetch32", sizeof(int),     &StubRoutines::_safefetch32_entry,
3574                                                        &StubRoutines::_safefetch32_fault_pc,
3575                                                        &StubRoutines::_safefetch32_continuation_pc);
3576     generate_safefetch("SafeFetchN", sizeof(intptr_t), &StubRoutines::_safefetchN_entry,
3577                                                        &StubRoutines::_safefetchN_fault_pc,
3578                                                        &StubRoutines::_safefetchN_continuation_pc);
3579 
3580 #ifdef COMPILER2
3581     if (UseMultiplyToLenIntrinsic) {
3582       StubRoutines::_multiplyToLen = generate_multiplyToLen();
3583     }


3584     if (UseSquareToLenIntrinsic) {
3585       StubRoutines::_squareToLen = generate_squareToLen();
3586     }
3587     if (UseMulAddIntrinsic) {
3588       StubRoutines::_mulAdd = generate_mulAdd();
3589     }
3590     if (UseMontgomeryMultiplyIntrinsic) {
3591       StubRoutines::_montgomeryMultiply
3592         = CAST_FROM_FN_PTR(address, SharedRuntime::montgomery_multiply);
3593     }
3594     if (UseMontgomerySquareIntrinsic) {
3595       StubRoutines::_montgomerySquare
3596         = CAST_FROM_FN_PTR(address, SharedRuntime::montgomery_square);
3597     }
3598 #endif
3599 
3600     if (UseAESIntrinsics) {
3601       StubRoutines::_aescrypt_encryptBlock = generate_aescrypt_encryptBlock();
3602       StubRoutines::_aescrypt_decryptBlock = generate_aescrypt_decryptBlock();
3603     }
3604 
3605     if (UseSHA256Intrinsics) {
3606       StubRoutines::_sha256_implCompress   = generate_sha256_implCompress(false, "sha256_implCompress");
3607       StubRoutines::_sha256_implCompressMB = generate_sha256_implCompress(true,  "sha256_implCompressMB");
3608     }
3609     if (UseSHA512Intrinsics) {
3610       StubRoutines::_sha512_implCompress   = generate_sha512_implCompress(false, "sha512_implCompress");
3611       StubRoutines::_sha512_implCompressMB = generate_sha512_implCompress(true, "sha512_implCompressMB");
3612     }
3613   }
3614 
3615  public:
3616   StubGenerator(CodeBuffer* code, bool all) : StubCodeGenerator(code) {
3617     // replace the standard masm with a special one:
3618     _masm = new MacroAssembler(code);
< prev index next >