218 219 // End of helpers 220 221 // Various method entries 222 223 // Abstract method entry 224 // Attempt to execute abstract method. Throw exception 225 // 226 address InterpreterGenerator::generate_abstract_entry(void) { 227 address entry = __ pc(); 228 // abstract method entry 229 // throw exception 230 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError)); 231 // the call_VM checks for exception, so we should never return here. 232 __ should_not_reach_here(); 233 return entry; 234 235 } 236 237 238 239 // Method handle invoker 240 // Dispatch a method of the form java.dyn.MethodHandles::invoke(...) 241 address InterpreterGenerator::generate_method_handle_entry(void) { 242 if (!EnableMethodHandles) { 243 return generate_abstract_entry(); 244 } 245 return generate_abstract_entry(); //6815692// 246 } 247 248 249 250 251 //---------------------------------------------------------------------------------------------------- 252 // Entry points & stack frame layout 253 // 254 // Here we generate the various kind of entries into the interpreter. 255 // The two main entry type are generic bytecode methods and native call method. 256 // These both come in synchronized and non-synchronized versions but the 257 // frame layout they create is very similar. The other method entry 258 // types are really just special purpose entries that are really entry 259 // and interpretation all in one. These are for trivial methods like 260 // accessor, empty, or special math methods. 261 // 262 // When control flow reaches any of the entry types for the interpreter 263 // the following holds -> 264 // 265 // C2 Calling Conventions: 266 // 267 // The entry code below assumes that the following registers are set 268 // when coming in: | 218 219 // End of helpers 220 221 // Various method entries 222 223 // Abstract method entry 224 // Attempt to execute abstract method. Throw exception 225 // 226 address InterpreterGenerator::generate_abstract_entry(void) { 227 address entry = __ pc(); 228 // abstract method entry 229 // throw exception 230 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError)); 231 // the call_VM checks for exception, so we should never return here. 232 __ should_not_reach_here(); 233 return entry; 234 235 } 236 237 238 // Method handle invoker 239 // Dispatch a method of the form java.dyn.MethodHandles::invoke(...) 240 address InterpreterGenerator::generate_method_handle_entry(void) { 241 if (!EnableMethodHandles) { 242 return generate_abstract_entry(); 243 } 244 245 return MethodHandles::generate_method_handle_interpreter_entry(_masm); 246 } 247 248 249 //---------------------------------------------------------------------------------------------------- 250 // Entry points & stack frame layout 251 // 252 // Here we generate the various kind of entries into the interpreter. 253 // The two main entry type are generic bytecode methods and native call method. 254 // These both come in synchronized and non-synchronized versions but the 255 // frame layout they create is very similar. The other method entry 256 // types are really just special purpose entries that are really entry 257 // and interpretation all in one. These are for trivial methods like 258 // accessor, empty, or special math methods. 259 // 260 // When control flow reaches any of the entry types for the interpreter 261 // the following holds -> 262 // 263 // C2 Calling Conventions: 264 // 265 // The entry code below assumes that the following registers are set 266 // when coming in: |