< prev index next >

src/hotspot/cpu/zero/sharedRuntime_zero.cpp

Print this page

 33 #include "vmreg_zero.inline.hpp"
 34 #ifdef COMPILER1
 35 #include "c1/c1_Runtime1.hpp"
 36 #endif
 37 #ifdef COMPILER2
 38 #include "opto/runtime.hpp"
 39 #endif
 40 
 41 
 42 static address zero_null_code_stub() {
 43   address start = ShouldNotCallThisStub();
 44   return start;
 45 }
 46 
 47 int SharedRuntime::java_calling_convention(const BasicType *sig_bt,
 48                                            VMRegPair *regs,
 49                                            int total_args_passed) {
 50   return 0;
 51 }
 52 
 53 AdapterHandlerEntry* SharedRuntime::generate_i2c2i_adapters(
 54                         MacroAssembler *masm,
 55                         int total_args_passed,
 56                         int comp_args_on_stack,
 57                         const BasicType *sig_bt,
 58                         const VMRegPair *regs,
 59                         AdapterFingerPrint *fingerprint) {



















 60   return AdapterHandlerLibrary::new_entry(
 61     fingerprint,
 62     CAST_FROM_FN_PTR(address,zero_null_code_stub),
 63     CAST_FROM_FN_PTR(address,zero_null_code_stub),




 64     CAST_FROM_FN_PTR(address,zero_null_code_stub));
 65 }
 66 
 67 nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm,
 68                                                 const methodHandle& method,
 69                                                 int compile_id,
 70                                                 BasicType *sig_bt,
 71                                                 VMRegPair *regs,
 72                                                 BasicType ret_type) {
 73   ShouldNotCallThis();
 74   return nullptr;
 75 }
 76 
 77 int Deoptimization::last_frame_adjust(int callee_parameters,
 78                                       int callee_locals) {
 79   return 0;
 80 }
 81 
 82 uint SharedRuntime::out_preserve_stack_slots() {
 83   ShouldNotCallThis();

 33 #include "vmreg_zero.inline.hpp"
 34 #ifdef COMPILER1
 35 #include "c1/c1_Runtime1.hpp"
 36 #endif
 37 #ifdef COMPILER2
 38 #include "opto/runtime.hpp"
 39 #endif
 40 
 41 
 42 static address zero_null_code_stub() {
 43   address start = ShouldNotCallThisStub();
 44   return start;
 45 }
 46 
 47 int SharedRuntime::java_calling_convention(const BasicType *sig_bt,
 48                                            VMRegPair *regs,
 49                                            int total_args_passed) {
 50   return 0;
 51 }
 52 
 53 int SharedRuntime::java_return_convention(const BasicType *sig_bt,
 54                                            VMRegPair *regs,
 55                                            int total_args_passed) {
 56   Unimplemented();
 57   return 0;
 58 }
 59 
 60 BufferedInlineTypeBlob* SharedRuntime::generate_buffered_inline_type_adapter(const InlineKlass* vk) {
 61   Unimplemented();
 62   return nullptr;
 63 }
 64 
 65 AdapterHandlerEntry* SharedRuntime::generate_i2c2i_adapters(MacroAssembler* masm,
 66                                                             int comp_args_on_stack,
 67                                                             const GrowableArray <SigEntry>* sig,
 68                                                             const VMRegPair* regs,
 69                                                             const GrowableArray <SigEntry>* sig_cc,
 70                                                             const VMRegPair* regs_cc,
 71                                                             const GrowableArray <SigEntry>* sig_cc_ro,
 72                                                             const VMRegPair* regs_cc_ro,
 73                                                             AdapterFingerPrint* fingerprint,
 74                                                             AdapterBlob*& new_adapter,
 75                                                             bool allocate_code_blob) {
 76   if (allocate_code_blob) {
 77     new_adapter = AdapterBlob::create(masm->code(), 0, 0, nullptr);
 78   }
 79   return AdapterHandlerLibrary::new_entry(
 80     fingerprint,
 81     CAST_FROM_FN_PTR(address,zero_null_code_stub),
 82     CAST_FROM_FN_PTR(address,zero_null_code_stub),
 83     CAST_FROM_FN_PTR(address,zero_null_code_stub),
 84     CAST_FROM_FN_PTR(address,zero_null_code_stub),
 85     CAST_FROM_FN_PTR(address,zero_null_code_stub),
 86     CAST_FROM_FN_PTR(address,zero_null_code_stub),
 87     CAST_FROM_FN_PTR(address,zero_null_code_stub));
 88 }
 89 
 90 nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm,
 91                                                 const methodHandle& method,
 92                                                 int compile_id,
 93                                                 BasicType *sig_bt,
 94                                                 VMRegPair *regs,
 95                                                 BasicType ret_type) {
 96   ShouldNotCallThis();
 97   return nullptr;
 98 }
 99 
100 int Deoptimization::last_frame_adjust(int callee_parameters,
101                                       int callee_locals) {
102   return 0;
103 }
104 
105 uint SharedRuntime::out_preserve_stack_slots() {
106   ShouldNotCallThis();
< prev index next >