162 #ifndef _LP64 163 case T_OBJECT : // fall through 164 case T_ARRAY : // fall through 165 #endif 166 case T_BYTE : // fall through 167 case T_VOID : return T_INT; 168 case T_LONG : return T_LONG; 169 case T_FLOAT : return T_FLOAT; 170 case T_DOUBLE : return T_DOUBLE; 171 #ifdef _LP64 172 case T_ARRAY : // fall through 173 case T_OBJECT: return T_OBJECT; 174 #endif 175 } 176 ShouldNotReachHere(); 177 return T_ILLEGAL; 178 } 179 180 // ============ Virtual calls ============ 181 182 void JavaCalls::call_virtual(JavaValue* result, KlassHandle spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 183 CallInfo callinfo; 184 Handle receiver = args->receiver(); 185 KlassHandle recvrKlass(THREAD, receiver.is_null() ? (Klass*)NULL : receiver->klass()); 186 LinkInfo link_info(spec_klass, name, signature); 187 LinkResolver::resolve_virtual_call( 188 callinfo, receiver, recvrKlass, link_info, true, CHECK); 189 methodHandle method = callinfo.selected_method(); 190 assert(method.not_null(), "should have thrown exception"); 191 192 // Invoke the method 193 JavaCalls::call(result, method, args, CHECK); 194 } 195 196 197 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, TRAPS) { 198 JavaCallArguments args(receiver); // One oop argument 199 call_virtual(result, spec_klass, name, signature, &args, CHECK); 200 } 201 202 203 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 204 JavaCallArguments args(receiver); // One oop argument 205 args.push_oop(arg1); 206 call_virtual(result, spec_klass, name, signature, &args, CHECK); 207 } 208 209 210 211 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 212 JavaCallArguments args(receiver); // One oop argument 213 args.push_oop(arg1); 214 args.push_oop(arg2); 215 call_virtual(result, spec_klass, name, signature, &args, CHECK); 216 } 217 218 219 // ============ Special calls ============ 220 221 void JavaCalls::call_special(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 222 CallInfo callinfo; 223 LinkInfo link_info(klass, name, signature); 224 LinkResolver::resolve_special_call(callinfo, link_info, CHECK); 225 methodHandle method = callinfo.selected_method(); 226 assert(method.not_null(), "should have thrown exception"); 227 228 // Invoke the method 229 JavaCalls::call(result, method, args, CHECK); 230 } 231 232 233 void JavaCalls::call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { 234 JavaCallArguments args(receiver); // One oop argument 235 call_special(result, klass, name, signature, &args, CHECK); 236 } 237 238 239 void JavaCalls::call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 240 JavaCallArguments args(receiver); // One oop argument 241 args.push_oop(arg1); 242 call_special(result, klass, name, signature, &args, CHECK); 243 } 244 245 246 void JavaCalls::call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 247 JavaCallArguments args(receiver); // One oop argument 248 args.push_oop(arg1); 249 args.push_oop(arg2); 250 call_special(result, klass, name, signature, &args, CHECK); 251 } 252 253 254 // ============ Static calls ============ 255 256 void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 257 CallInfo callinfo; 258 LinkInfo link_info(klass, name, signature); 259 LinkResolver::resolve_static_call(callinfo, link_info, true, CHECK); 260 methodHandle method = callinfo.selected_method(); 261 assert(method.not_null(), "should have thrown exception"); 262 263 // Invoke the method 264 JavaCalls::call(result, method, args, CHECK); 265 } 266 267 268 void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { 269 JavaCallArguments args; // No argument 270 call_static(result, klass, name, signature, &args, CHECK); 271 } 272 273 274 void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 275 JavaCallArguments args(arg1); // One oop argument 276 call_static(result, klass, name, signature, &args, CHECK); 277 } 278 279 280 void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 281 JavaCallArguments args; // One oop argument 282 args.push_oop(arg1); 283 args.push_oop(arg2); 284 call_static(result, klass, name, signature, &args, CHECK); 285 } 286 287 288 void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, Handle arg3, TRAPS) { 289 JavaCallArguments args; // One oop argument 290 args.push_oop(arg1); 291 args.push_oop(arg2); 292 args.push_oop(arg3); 293 call_static(result, klass, name, signature, &args, CHECK); 294 } 295 296 // ------------------------------------------------- 297 // Implementation of JavaCalls (low level) 298 299 300 void JavaCalls::call(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) { 301 // Check if we need to wrap a potential OS exception handler around thread 302 // This is used for e.g. Win32 structured exception handlers 303 assert(THREAD->is_Java_thread(), "only JavaThreads can make JavaCalls"); 304 // Need to wrap each and every time, since there might be native code down the 305 // stack that has installed its own exception handlers 306 os::os_exception_wrapper(call_helper, result, method, args, THREAD); 307 } 308 | 162 #ifndef _LP64 163 case T_OBJECT : // fall through 164 case T_ARRAY : // fall through 165 #endif 166 case T_BYTE : // fall through 167 case T_VOID : return T_INT; 168 case T_LONG : return T_LONG; 169 case T_FLOAT : return T_FLOAT; 170 case T_DOUBLE : return T_DOUBLE; 171 #ifdef _LP64 172 case T_ARRAY : // fall through 173 case T_OBJECT: return T_OBJECT; 174 #endif 175 } 176 ShouldNotReachHere(); 177 return T_ILLEGAL; 178 } 179 180 // ============ Virtual calls ============ 181 182 void JavaCalls::call_virtual(JavaValue* result, Klass* spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 183 CallInfo callinfo; 184 Handle receiver = args->receiver(); 185 Klass* recvrKlass = receiver.is_null() ? (Klass*)NULL : receiver->klass(); 186 LinkInfo link_info(spec_klass, name, signature); 187 LinkResolver::resolve_virtual_call( 188 callinfo, receiver, recvrKlass, link_info, true, CHECK); 189 methodHandle method = callinfo.selected_method(); 190 assert(method.not_null(), "should have thrown exception"); 191 192 // Invoke the method 193 JavaCalls::call(result, method, args, CHECK); 194 } 195 196 197 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, TRAPS) { 198 JavaCallArguments args(receiver); // One oop argument 199 call_virtual(result, spec_klass, name, signature, &args, CHECK); 200 } 201 202 203 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 204 JavaCallArguments args(receiver); // One oop argument 205 args.push_oop(arg1); 206 call_virtual(result, spec_klass, name, signature, &args, CHECK); 207 } 208 209 210 211 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 212 JavaCallArguments args(receiver); // One oop argument 213 args.push_oop(arg1); 214 args.push_oop(arg2); 215 call_virtual(result, spec_klass, name, signature, &args, CHECK); 216 } 217 218 219 // ============ Special calls ============ 220 221 void JavaCalls::call_special(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 222 CallInfo callinfo; 223 LinkInfo link_info(klass, name, signature); 224 LinkResolver::resolve_special_call(callinfo, link_info, CHECK); 225 methodHandle method = callinfo.selected_method(); 226 assert(method.not_null(), "should have thrown exception"); 227 228 // Invoke the method 229 JavaCalls::call(result, method, args, CHECK); 230 } 231 232 233 void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, TRAPS) { 234 JavaCallArguments args(receiver); // One oop argument 235 call_special(result, klass, name, signature, &args, CHECK); 236 } 237 238 239 void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 240 JavaCallArguments args(receiver); // One oop argument 241 args.push_oop(arg1); 242 call_special(result, klass, name, signature, &args, CHECK); 243 } 244 245 246 void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 247 JavaCallArguments args(receiver); // One oop argument 248 args.push_oop(arg1); 249 args.push_oop(arg2); 250 call_special(result, klass, name, signature, &args, CHECK); 251 } 252 253 254 // ============ Static calls ============ 255 256 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 257 CallInfo callinfo; 258 LinkInfo link_info(klass, name, signature); 259 LinkResolver::resolve_static_call(callinfo, link_info, true, CHECK); 260 methodHandle method = callinfo.selected_method(); 261 assert(method.not_null(), "should have thrown exception"); 262 263 // Invoke the method 264 JavaCalls::call(result, method, args, CHECK); 265 } 266 267 268 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, TRAPS) { 269 JavaCallArguments args; // No argument 270 call_static(result, klass, name, signature, &args, CHECK); 271 } 272 273 274 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 275 JavaCallArguments args(arg1); // One oop argument 276 call_static(result, klass, name, signature, &args, CHECK); 277 } 278 279 280 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 281 JavaCallArguments args; // One oop argument 282 args.push_oop(arg1); 283 args.push_oop(arg2); 284 call_static(result, klass, name, signature, &args, CHECK); 285 } 286 287 288 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, Handle arg3, TRAPS) { 289 JavaCallArguments args; // One oop argument 290 args.push_oop(arg1); 291 args.push_oop(arg2); 292 args.push_oop(arg3); 293 call_static(result, klass, name, signature, &args, CHECK); 294 } 295 296 // ------------------------------------------------- 297 // Implementation of JavaCalls (low level) 298 299 300 void JavaCalls::call(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) { 301 // Check if we need to wrap a potential OS exception handler around thread 302 // This is used for e.g. Win32 structured exception handlers 303 assert(THREAD->is_Java_thread(), "only JavaThreads can make JavaCalls"); 304 // Need to wrap each and every time, since there might be native code down the 305 // stack that has installed its own exception handlers 306 os::os_exception_wrapper(call_helper, result, method, args, THREAD); 307 } 308 |