src/hotspot/share/opto/callGenerator.cpp

*** 121,138 ****
    bool                _separate_io_proj;
  
   public:
    DirectCallGenerator(ciMethod* method, bool separate_io_proj)
      : CallGenerator(method),
        _separate_io_proj(separate_io_proj)
    {
!     // TODO fix this with the calling convention changes
!     if (false /*method->signature()->return_type()->is__Value()*/) {
!       // If that call has not been optimized by the time optimizations
!       // are over, we'll need to add a call to create a value type
!       // instance from the klass returned by the call. Separating
!       // memory and I/O projections for exceptions is required to
        // perform that graph transformation.
        _separate_io_proj = true;
      }
    }
    virtual JVMState* generate(JVMState* jvms);
--- 121,138 ----
    bool                _separate_io_proj;
  
   public:
    DirectCallGenerator(ciMethod* method, bool separate_io_proj)
      : CallGenerator(method),
+       _call_node(NULL),
        _separate_io_proj(separate_io_proj)
    {
!     if (ValueTypeReturnedAsFields && method->is_method_handle_intrinsic()) {
!       // If that call has not been optimized by the time optimizations are over,
!       // we'll need to add a call to create a value type instance from the klass
!       // returned by the call (see PhaseMacroExpand::expand_mh_intrinsic_return).
!       // Separating memory and I/O projections for exceptions is required to
        // perform that graph transformation.
        _separate_io_proj = true;
      }
    }
    virtual JVMState* generate(JVMState* jvms);
*** 434,461 ****
    assert(domain_sig->cnt() - TypeFunc::Parms == nargs, "inconsistent signature");
  
    uint j = TypeFunc::Parms;
    for (uint i1 = 0; i1 < nargs; i1++) {
      const Type* t = domain_sig->field_at(TypeFunc::Parms + i1);
!     if (!ValueTypePassFieldsAsArgs) {
!       Node* arg = call->in(TypeFunc::Parms + i1);
!       map->set_argument(jvms, i1, arg);
!     } else {
!       assert(false, "FIXME");
!       // TODO move this into Parse::Parse because we might need to deopt
!       /*
        GraphKit arg_kit(jvms, &gvn);
!       if (t->is_valuetypeptr()) {
!         ciValueKlass* vk = t->value_klass();
!         ValueTypeNode* vt = ValueTypeNode::make_from_multi(&arg_kit, call, vk, j, true);
!         arg_kit.set_argument(i1, vt);
!         j += vk->value_arg_slots();
        } else {
!         arg_kit.set_argument(i1, call->in(j));
          j++;
        }
!       */
      }
    }
  
    C->print_inlining_assert_ready();
  
--- 434,464 ----
    assert(domain_sig->cnt() - TypeFunc::Parms == nargs, "inconsistent signature");
  
    uint j = TypeFunc::Parms;
    for (uint i1 = 0; i1 < nargs; i1++) {
      const Type* t = domain_sig->field_at(TypeFunc::Parms + i1);
!     if (method()->get_Method()->has_scalarized_args()) {
        GraphKit arg_kit(jvms, &gvn);
!       // TODO for now, don't scalarize value type receivers because of interface calls
!       if (t->is_valuetypeptr() && (method()->is_static() || i1 != 0)) {
!         arg_kit.set_control(map->control());
!         ValueTypeNode* vt = ValueTypeNode::make_from_multi(&arg_kit, call, t->value_klass(), j, true);
!         map->set_control(arg_kit.control());
!         map->set_argument(jvms, i1, vt);
        } else {
!         int index = j;
!         SigEntry res_entry = method()->get_Method()->get_res_entry();
!         if (res_entry._offset != -1 && (index - TypeFunc::Parms) >= res_entry._offset) {
!           // Skip reserved entry
!           index += type2size[res_entry._bt];
!         }
!         map->set_argument(jvms, i1, call->in(index));
          j++;
        }
!     } else {
!       Node* arg = call->in(TypeFunc::Parms + i1);
!       map->set_argument(jvms, i1, arg);
      }
    }
  
    C->print_inlining_assert_ready();
  
*** 500,523 ****
  
    // Handle value type returns
    bool returned_as_fields = call->tf()->returns_value_type_as_fields();
    if (result->is_ValueType()) {
      ValueTypeNode* vt = result->as_ValueType();
!     if (!returned_as_fields) {
!       result = ValueTypePtrNode::make_from_value_type(&kit, vt);
!     } else {
!       assert(false, "FIXME");
        // Return of multiple values (the fields of a value type)
        vt->replace_call_results(&kit, call, C);
!       if (gvn.type(vt->get_oop()) == TypePtr::NULL_PTR) {
!         result = vt->tagged_klass(gvn);
!       } else {
          result = vt->get_oop();
        }
      }
    } else if (gvn.type(result)->is_valuetypeptr() && returned_as_fields) {
-     assert(false, "FIXME");
      const Type* vt_t = call->_tf->range_sig()->field_at(TypeFunc::Parms);
      Node* cast = new CheckCastPPNode(NULL, result, vt_t);
      gvn.record_for_igvn(cast);
      ValueTypePtrNode* vtptr = ValueTypePtrNode::make_from_oop(&kit, gvn.transform(cast));
      vtptr->replace_call_results(&kit, call, C);
--- 503,524 ----
  
    // Handle value type returns
    bool returned_as_fields = call->tf()->returns_value_type_as_fields();
    if (result->is_ValueType()) {
      ValueTypeNode* vt = result->as_ValueType();
!     if (returned_as_fields) {
        // Return of multiple values (the fields of a value type)
        vt->replace_call_results(&kit, call, C);
!       if (vt->is_allocated(&gvn) && !StressValueTypeReturnedAsFields) {
          result = vt->get_oop();
+       } else {
+         result = vt->tagged_klass(gvn);
        }
+     } else {
+       result = ValueTypePtrNode::make_from_value_type(&kit, vt);
      }
    } else if (gvn.type(result)->is_valuetypeptr() && returned_as_fields) {
      const Type* vt_t = call->_tf->range_sig()->field_at(TypeFunc::Parms);
      Node* cast = new CheckCastPPNode(NULL, result, vt_t);
      gvn.record_for_igvn(cast);
      ValueTypePtrNode* vtptr = ValueTypePtrNode::make_from_oop(&kit, gvn.transform(cast));
      vtptr->replace_call_results(&kit, call, C);