Print this page
Split Close
Expand all
Collapse all
          --- old/src/share/vm/c1/c1_LIRGenerator.cpp
          +++ new/src/share/vm/c1/c1_LIRGenerator.cpp
↓ open down ↓ 2276 lines elided ↑ open up ↑ 
2277 2277  void LIRGenerator::do_OsrEntry(OsrEntry* x) {
2278 2278    // construct our frame and model the production of incoming pointer
2279 2279    // to the OSR buffer.
2280 2280    __ osr_entry(LIR_Assembler::osrBufferPointer());
2281 2281    LIR_Opr result = rlock_result(x);
2282 2282    __ move(LIR_Assembler::osrBufferPointer(), result);
2283 2283  }
2284 2284  
2285 2285  
2286 2286  void LIRGenerator::invoke_load_arguments(Invoke* x, LIRItemList* args, const LIR_OprList* arg_list) {
2287      -  int i = x->has_receiver() ? 1 : 0;
     2287 +  int i = (x->has_receiver() || x->is_invokedynamic()) ? 1 : 0;
2288 2288    for (; i < args->length(); i++) {
2289 2289      LIRItem* param = args->at(i);
2290 2290      LIR_Opr loc = arg_list->at(i);
2291 2291      if (loc->is_register()) {
2292 2292        param->load_item_force(loc);
2293 2293      } else {
2294 2294        LIR_Address* addr = loc->as_address_ptr();
2295 2295        param->load_for_store(addr->type());
2296 2296        if (addr->type() == T_LONG || addr->type() == T_DOUBLE) {
2297 2297          __ unaligned_move(param->result(), addr);
↓ open down ↓ 17 lines elided ↑ open up ↑ 
2315 2315  }
2316 2316  
2317 2317  
2318 2318  // Visits all arguments, returns appropriate items without loading them
2319 2319  LIRItemList* LIRGenerator::invoke_visit_arguments(Invoke* x) {
2320 2320    LIRItemList* argument_items = new LIRItemList();
2321 2321    if (x->has_receiver()) {
2322 2322      LIRItem* receiver = new LIRItem(x->receiver(), this);
2323 2323      argument_items->append(receiver);
2324 2324    }
     2325 +  if (x->is_invokedynamic()) {
     2326 +    // Insert a dummy for the synthetic MethodHandle argument.
     2327 +    argument_items->append(NULL);
     2328 +  }
2325 2329    int idx = x->has_receiver() ? 1 : 0;
2326 2330    for (int i = 0; i < x->number_of_arguments(); i++) {
2327 2331      LIRItem* param = new LIRItem(x->argument_at(i), this);
2328 2332      argument_items->append(param);
2329 2333      idx += (param->type()->is_double_word() ? 2 : 1);
2330 2334    }
2331 2335    return argument_items;
2332 2336  }
2333 2337  
2334 2338
↓ open down ↓ 29 lines elided ↑ open up ↑ 
2364 2368    LIR_Opr receiver = LIR_OprFact::illegalOpr;
2365 2369  
2366 2370    // setup result register
2367 2371    LIR_Opr result_register = LIR_OprFact::illegalOpr;
2368 2372    if (x->type() != voidType) {
2369 2373      result_register = result_register_for(x->type());
2370 2374    }
2371 2375  
2372 2376    CodeEmitInfo* info = state_for(x, x->state());
2373 2377  
     2378 +  // invokedynamics can deoptimize.
     2379 +  bool is_invokedynamic = x->code() == Bytecodes::_invokedynamic;
     2380 +  CodeEmitInfo* deopt_info = is_invokedynamic ? state_for(x, x->state_before()) : NULL;
     2381 +
2374 2382    invoke_load_arguments(x, args, arg_list);
2375 2383  
2376 2384    if (x->has_receiver()) {
2377 2385      args->at(0)->load_item_force(LIR_Assembler::receiverOpr());
2378 2386      receiver = args->at(0)->result();
2379 2387    }
2380 2388  
2381 2389    // emit invoke code
2382 2390    bool optimized = x->target_is_loaded() && x->target_is_final();
2383 2391    assert(receiver->is_illegal() || receiver->is_equal(LIR_Assembler::receiverOpr()), "must match");
↓ open down ↓ 16 lines elided ↑ open up ↑ 
2400 2408        } else if (x->vtable_index() < 0) {
2401 2409          __ call_icvirtual(x->target(), receiver, result_register,
2402 2410                            SharedRuntime::get_resolve_virtual_call_stub(),
2403 2411                            arg_list, info);
2404 2412        } else {
2405 2413          int entry_offset = instanceKlass::vtable_start_offset() + x->vtable_index() * vtableEntry::size();
2406 2414          int vtable_offset = entry_offset * wordSize + vtableEntry::method_offset_in_bytes();
2407 2415          __ call_virtual(x->target(), receiver, result_register, vtable_offset, arg_list, info);
2408 2416        }
2409 2417        break;
     2418 +    case Bytecodes::_invokedynamic: {
     2419 +      ciBytecodeStream bcs(x->scope()->method());
     2420 +      bcs.force_bci(x->bci());
     2421 +      assert(bcs.cur_bc() == Bytecodes::_invokedynamic, "wrong stream");
     2422 +      ciCPCache* cpcache = bcs.get_cpcache();
     2423 +
     2424 +      // Get CallSite offset from constant pool cache pointer.
     2425 +      int index = bcs.get_method_index();
     2426 +      size_t call_site_offset = cpcache->get_f1_offset(index);
     2427 +
     2428 +      // If this invokedynamic call site hasn't been executed yet in
     2429 +      // the interpreter, the CallSite object in the constant pool
     2430 +      // cache is still null and we need to deoptimize.
     2431 +      if (cpcache->is_f1_null_at(index)) {
     2432 +        // Cannot re-use same xhandlers for multiple CodeEmitInfos, so
     2433 +        // clone all handlers.  This is handled transparently in other
     2434 +        // places by the CodeEmitInfo cloning logic but is handled
     2435 +        // specially here because a stub isn't being used.
     2436 +        x->set_exception_handlers(new XHandlers(x->exception_handlers()));
     2437 +
     2438 +        DeoptimizeStub* deopt_stub = new DeoptimizeStub(deopt_info);
     2439 +        __ jump(deopt_stub);
     2440 +      }
     2441 +
     2442 +      // Use the receiver register for the synthetic MethodHandle
     2443 +      // argument.
     2444 +      receiver = LIR_Assembler::receiverOpr();
     2445 +      LIR_Opr tmp = new_register(objectType);
     2446 +
     2447 +      // Load CallSite object from constant pool cache.
     2448 +      __ oop2reg(cpcache->constant_encoding(), tmp);
     2449 +      __ load(new LIR_Address(tmp, call_site_offset, T_OBJECT), tmp);
     2450 +
     2451 +      // Load target MethodHandle from CallSite object.
     2452 +      __ load(new LIR_Address(tmp, java_dyn_CallSite::target_offset_in_bytes(), T_OBJECT), receiver);
     2453 +
     2454 +      __ call_dynamic(x->target(), receiver, result_register,
     2455 +                      SharedRuntime::get_resolve_opt_virtual_call_stub(),
     2456 +                      arg_list, info);
     2457 +      break;
     2458 +    }
2410 2459      default:
2411 2460        ShouldNotReachHere();
2412 2461        break;
2413 2462    }
2414 2463  
2415 2464    if (x->type()->is_float() || x->type()->is_double()) {
2416 2465      // Force rounding of results from non-strictfp when in strictfp
2417 2466      // scope (or when we don't know the strictness of the callee, to
2418 2467      // be safe.)
2419 2468      if (method()->is_strict()) {
↓ open down ↓ 281 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX