runtime/method_handles.cc - platform/art - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "method_handles.h"

 #include "method_handles-inl.h"
 #include "jvalue.h"
 #include "jvalue-inl.h"
 #include "reflection.h"
 #include "reflection-inl.h"

 namespace art {

 namespace {

 static const char* kBoxedBooleanClass = "Ljava/lang/Boolean;";
 static const char* kBoxedByteClass = "Ljava/lang/Byte;";
 static const char* kBoxedCharacterClass = "Ljava/lang/Character;";
 static const char* kBoxedDoubleClass = "Ljava/lang/Double;";
 static const char* kBoxedFloatClass = "Ljava/lang/Float;";
 static const char* kBoxedIntegerClass = "Ljava/lang/Integer;";
 static const char* kBoxedLongClass = "Ljava/lang/Long;";
 static const char* kBoxedShortClass = "Ljava/lang/Short;";

 // Assigns |type| to the primitive type associated with |klass|. Returns
 // true iff. |klass| was a boxed type (Integer, Long etc.), false otherwise.
 bool GetUnboxedPrimitiveType(ObjPtr<mirror::Class> klass, Primitive::Type* type)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   ScopedAssertNoThreadSuspension ants(__FUNCTION__);
   if (klass->DescriptorEquals(kBoxedBooleanClass)) {
     (*type) = Primitive::kPrimBoolean;
     return true;
   } else if (klass->DescriptorEquals(kBoxedByteClass)) {
     (*type) = Primitive::kPrimByte;
     return true;
   } else if (klass->DescriptorEquals(kBoxedCharacterClass)) {
     (*type) = Primitive::kPrimChar;
     return true;
   } else if (klass->DescriptorEquals(kBoxedFloatClass)) {
     (*type) = Primitive::kPrimFloat;
     return true;
   } else if (klass->DescriptorEquals(kBoxedDoubleClass)) {
     (*type) = Primitive::kPrimDouble;
     return true;
   } else if (klass->DescriptorEquals(kBoxedIntegerClass)) {
     (*type) = Primitive::kPrimInt;
     return true;
   } else if (klass->DescriptorEquals(kBoxedLongClass)) {
     (*type) = Primitive::kPrimLong;
     return true;
   } else if (klass->DescriptorEquals(kBoxedShortClass)) {
     (*type) = Primitive::kPrimShort;
     return true;
   } else {
     return false;
   }
 }

 // Returns the class corresponding to the boxed type for the primitive |type|.
 ObjPtr<mirror::Class> GetBoxedPrimitiveClass(Primitive::Type type)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   ScopedAssertNoThreadSuspension ants(__FUNCTION__);
   ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
   switch (type) {
     case Primitive::kPrimBoolean:
       return class_linker->FindSystemClass(Thread::Current(), kBoxedBooleanClass);
     case Primitive::kPrimByte:
       return class_linker->FindSystemClass(Thread::Current(), kBoxedByteClass);
     case Primitive::kPrimChar:
       return class_linker->FindSystemClass(Thread::Current(), kBoxedCharacterClass);
     case Primitive::kPrimShort:
       return class_linker->FindSystemClass(Thread::Current(), kBoxedShortClass);
     case Primitive::kPrimInt:
       return class_linker->FindSystemClass(Thread::Current(), kBoxedIntegerClass);
     case Primitive::kPrimLong:
       return class_linker->FindSystemClass(Thread::Current(), kBoxedLongClass);
     case Primitive::kPrimFloat:
       return class_linker->FindSystemClass(Thread::Current(), kBoxedFloatClass);
     case Primitive::kPrimDouble:
       return class_linker->FindSystemClass(Thread::Current(), kBoxedDoubleClass);
     case Primitive::kPrimNot:
     case Primitive::kPrimVoid:
       LOG(FATAL) << "Unreachable";
       return nullptr;
   }
 }

 // Returns true if |klass| is a boxed primitive type or a sub-class of a boxed primitive type.
 bool IsSubClassOfBoxedPrimitive(const Handle<mirror::Class>& klass)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   StackHandleScope<1> hs(Thread::Current());
   MutableHandle<mirror::Class> h_klass(hs.NewHandle(klass.Get()));
   do {
     Primitive::Type type;
     if (GetUnboxedPrimitiveType(h_klass.Get(), &type)) {
       return true;
     }
     h_klass.Assign(h_klass->GetSuperClass());
   } while (h_klass.Get() != nullptr);
   return false;
 }

 // Unboxed the value |o| to |unboxed_value| of type |dst_class|.
 // |unboxed_value| must be zero on entry to avoid dangling pointers.
 // Returns true on success, false if an exception is raised.
 bool UnboxPrimitiveForMethodHandles(ObjPtr<mirror::Object> o,
                                     ObjPtr<mirror::Class> dst_class,
                                     JValue* unboxed_value)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   // Check unboxed_value does not contain a dangling pointer.
   DCHECK_EQ(unboxed_value->GetJ(), 0);
   DCHECK(dst_class->IsPrimitive());

   // This is derived from UnboxPrimitive() in reflection.cc, but with
   // exceptions appropriate to method handles.
   if (UNLIKELY(dst_class->GetPrimitiveType() == Primitive::kPrimVoid)) {
     ThrowClassCastException(o->GetClass(), dst_class);
     return false;
   }
   if (UNLIKELY(o == nullptr)) {
     ThrowNullPointerException(
         StringPrintf("Expected to unbox a '%s' primitive type but was returned null",
                      dst_class->PrettyDescriptor().c_str()).c_str());
     return false;
   }

   JValue boxed_value;
   ObjPtr<mirror::Class> klass = o->GetClass();
   ObjPtr<mirror::Class> src_class = nullptr;
   ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
   ArtField* primitive_field = &klass->GetIFieldsPtr()->At(0);
   if (klass->DescriptorEquals(kBoxedBooleanClass)) {
     src_class = class_linker->FindPrimitiveClass('Z');
     boxed_value.SetZ(primitive_field->GetBoolean(o));
   } else if (klass->DescriptorEquals(kBoxedByteClass)) {
     src_class = class_linker->FindPrimitiveClass('B');
     boxed_value.SetB(primitive_field->GetByte(o));
   } else if (klass->DescriptorEquals(kBoxedCharacterClass)) {
     src_class = class_linker->FindPrimitiveClass('C');
     boxed_value.SetC(primitive_field->GetChar(o));
   } else if (klass->DescriptorEquals(kBoxedFloatClass)) {
     src_class = class_linker->FindPrimitiveClass('F');
     boxed_value.SetF(primitive_field->GetFloat(o));
   } else if (klass->DescriptorEquals(kBoxedDoubleClass)) {
     src_class = class_linker->FindPrimitiveClass('D');
     boxed_value.SetD(primitive_field->GetDouble(o));
   } else if (klass->DescriptorEquals(kBoxedIntegerClass)) {
     src_class = class_linker->FindPrimitiveClass('I');
     boxed_value.SetI(primitive_field->GetInt(o));
   } else if (klass->DescriptorEquals(kBoxedLongClass)) {
     src_class = class_linker->FindPrimitiveClass('J');
     boxed_value.SetJ(primitive_field->GetLong(o));
   } else if (klass->DescriptorEquals(kBoxedShortClass)) {
     src_class = class_linker->FindPrimitiveClass('S');
     boxed_value.SetS(primitive_field->GetShort(o));
   } else {
     std::string temp;
     ThrowIllegalArgumentException(
         StringPrintf("result has type %s, got %s",
                      dst_class->PrettyDescriptor().c_str(),
                      PrettyDescriptor(o->GetClass()->GetDescriptor(&temp)).c_str()).c_str());
     return false;
   }

   if (!ConvertPrimitiveValueNoThrow(src_class->GetPrimitiveType(),
                                     dst_class->GetPrimitiveType(),
                                     boxed_value,
                                     unboxed_value)) {
     ThrowClassCastException(src_class, dst_class);
     return false;
   }
   return true;
 }

 inline bool IsReferenceType(Primitive::Type type) {
   return type == Primitive::kPrimNot;
 }

 inline bool IsPrimitiveType(Primitive::Type type) {
   return !IsReferenceType(type);
 }

 }  // namespace

 bool ConvertJValueCommon(
     Handle<mirror::MethodType> callsite_type,
     Handle<mirror::MethodType> callee_type,
     ObjPtr<mirror::Class> from,
     ObjPtr<mirror::Class> to,
     JValue* value) {
   // The reader maybe concerned about the safety of the heap object
   // that may be in |value|. There is only one case where allocation
   // is obviously needed and that's for boxing. However, in the case
   // of boxing |value| contains a non-reference type.

   const Primitive::Type from_type = from->GetPrimitiveType();
   const Primitive::Type to_type = to->GetPrimitiveType();

   // This method must be called only when the types don't match.
   DCHECK(from != to);

   if (IsPrimitiveType(from_type) && IsPrimitiveType(to_type)) {
     // The source and target types are both primitives.
     if (UNLIKELY(!ConvertPrimitiveValueNoThrow(from_type, to_type, *value, value))) {
       ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
       value->SetJ(0);
       return false;
     }
     return true;
   } else if (IsReferenceType(from_type) && IsReferenceType(to_type)) {
     // They're both reference types. If "from" is null, we can pass it
     // through unchanged. If not, we must generate a cast exception if
     // |to| is not assignable from the dynamic type of |ref|.
     //
     // Playing it safe with StackHandleScope here, not expecting any allocation
     // in mirror::Class::IsAssignable().
     StackHandleScope<2> hs(Thread::Current());
     Handle<mirror::Class> h_to(hs.NewHandle(to));
     Handle<mirror::Object> h_obj(hs.NewHandle(value->GetL()));

     // |value| will now be the result value, invalidate its existing value
     // as |h_obj| now owns it.
     value->SetJ(0);

     if (h_obj.Get() != nullptr && !to->IsAssignableFrom(h_obj->GetClass())) {
       ThrowClassCastException(h_to.Get(), h_obj->GetClass());
       return false;
     }
     value->SetL(h_obj.Get());
     return true;
   } else if (IsReferenceType(to_type)) {
     DCHECK(IsPrimitiveType(from_type));
     // Playing it safe with StackHandleScope here with regards to
     // GetUnboxedPrimitiveType() and GetBoxedPrimitiveClass().
     StackHandleScope<1> hs(Thread::Current());
     Handle<mirror::Class> h_to(hs.NewHandle(to));
     // The source type is a primitive and the target type is a reference, so we must box.
     // The target type maybe a super class of the boxed source type, for example,
     // if the source type is int, it's boxed type is java.lang.Integer, and the target
     // type could be java.lang.Number.
     Primitive::Type type;
     if (!GetUnboxedPrimitiveType(to, &type)) {
       ObjPtr<mirror::Class> boxed_from_class = GetBoxedPrimitiveClass(from_type);
       if (boxed_from_class->IsSubClass(h_to.Get())) {
         type = from_type;
       } else {
         value->SetJ(0);
         ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
         return false;
       }
     }

     if (UNLIKELY(from_type != type)) {
       value->SetJ(0);
       ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
       return false;
     }

     if (!ConvertPrimitiveValueNoThrow(from_type, type, *value, value)) {
       value->SetJ(0);
       ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
       return false;
     }

     // Then perform the actual boxing, and then set the reference.
     ObjPtr<mirror::Object> boxed = BoxPrimitive(type, *value);
     value->SetL(boxed.Ptr());
     return true;
   } else {
     // The source type is a reference and the target type is a primitive, so we must unbox.
     DCHECK(IsReferenceType(from_type));
     DCHECK(IsPrimitiveType(to_type));

     // Use StackHandleScope to protect |from|, |to|, and the reference
     // in |value| from heap re-arrangements that could be triggered
     // ahead of unboxing step.
     StackHandleScope<3> hs(Thread::Current());
     Handle<mirror::Class> h_to(hs.NewHandle(to));
     Handle<mirror::Class> h_from(hs.NewHandle(from));
     Handle<mirror::Object> h_obj(hs.NewHandle(value->GetL()));

     // |value| will now be the result value, invalidate its existing value
     // as |h_obj| now owns it.
     value->SetJ(0);

     // Check source type is a boxed primitive or has a boxed primitive super-class.
     ObjPtr<mirror::Class> boxed_to_class = GetBoxedPrimitiveClass(to_type);
     if (!IsSubClassOfBoxedPrimitive(h_from) && !boxed_to_class->IsSubClass(h_from.Get())) {
       ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
       return false;
     }

     if (h_obj.Get() == nullptr) {
       ThrowNullPointerException(
         StringPrintf("Expected to unbox a '%s' but instance was null",
                      h_from->PrettyDescriptor().c_str()).c_str());
       return false;
     }

     return UnboxPrimitiveForMethodHandles(h_obj.Get(), h_to.Get(), value);
   }
 }

 }  // namespace art
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "method_handles.h"

	#include "method_handles-inl.h"
	#include "jvalue.h"
	#include "jvalue-inl.h"
	#include "reflection.h"
	#include "reflection-inl.h"

	namespace art {

	namespace {

	static const char* kBoxedBooleanClass = "Ljava/lang/Boolean;";
	static const char* kBoxedByteClass = "Ljava/lang/Byte;";
	static const char* kBoxedCharacterClass = "Ljava/lang/Character;";
	static const char* kBoxedDoubleClass = "Ljava/lang/Double;";
	static const char* kBoxedFloatClass = "Ljava/lang/Float;";
	static const char* kBoxedIntegerClass = "Ljava/lang/Integer;";
	static const char* kBoxedLongClass = "Ljava/lang/Long;";
	static const char* kBoxedShortClass = "Ljava/lang/Short;";

	// Assigns \|type\| to the primitive type associated with \|klass\|. Returns
	// true iff. \|klass\| was a boxed type (Integer, Long etc.), false otherwise.
	bool GetUnboxedPrimitiveType(ObjPtr<mirror::Class> klass, Primitive::Type* type)
	REQUIRES_SHARED(Locks::mutator_lock_) {
	ScopedAssertNoThreadSuspension ants(__FUNCTION__);
	if (klass->DescriptorEquals(kBoxedBooleanClass)) {
	(*type) = Primitive::kPrimBoolean;
	return true;
	} else if (klass->DescriptorEquals(kBoxedByteClass)) {
	(*type) = Primitive::kPrimByte;
	return true;
	} else if (klass->DescriptorEquals(kBoxedCharacterClass)) {
	(*type) = Primitive::kPrimChar;
	return true;
	} else if (klass->DescriptorEquals(kBoxedFloatClass)) {
	(*type) = Primitive::kPrimFloat;
	return true;
	} else if (klass->DescriptorEquals(kBoxedDoubleClass)) {
	(*type) = Primitive::kPrimDouble;
	return true;
	} else if (klass->DescriptorEquals(kBoxedIntegerClass)) {
	(*type) = Primitive::kPrimInt;
	return true;
	} else if (klass->DescriptorEquals(kBoxedLongClass)) {
	(*type) = Primitive::kPrimLong;
	return true;
	} else if (klass->DescriptorEquals(kBoxedShortClass)) {
	(*type) = Primitive::kPrimShort;
	return true;
	} else {
	return false;
	}
	}

	// Returns the class corresponding to the boxed type for the primitive \|type\|.
	ObjPtr<mirror::Class> GetBoxedPrimitiveClass(Primitive::Type type)
	REQUIRES_SHARED(Locks::mutator_lock_) {
	ScopedAssertNoThreadSuspension ants(__FUNCTION__);
	ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
	switch (type) {
	case Primitive::kPrimBoolean:
	return class_linker->FindSystemClass(Thread::Current(), kBoxedBooleanClass);
	case Primitive::kPrimByte:
	return class_linker->FindSystemClass(Thread::Current(), kBoxedByteClass);
	case Primitive::kPrimChar:
	return class_linker->FindSystemClass(Thread::Current(), kBoxedCharacterClass);
	case Primitive::kPrimShort:
	return class_linker->FindSystemClass(Thread::Current(), kBoxedShortClass);
	case Primitive::kPrimInt:
	return class_linker->FindSystemClass(Thread::Current(), kBoxedIntegerClass);
	case Primitive::kPrimLong:
	return class_linker->FindSystemClass(Thread::Current(), kBoxedLongClass);
	case Primitive::kPrimFloat:
	return class_linker->FindSystemClass(Thread::Current(), kBoxedFloatClass);
	case Primitive::kPrimDouble:
	return class_linker->FindSystemClass(Thread::Current(), kBoxedDoubleClass);
	case Primitive::kPrimNot:
	case Primitive::kPrimVoid:
	LOG(FATAL) << "Unreachable";
	return nullptr;
	}
	}

	// Returns true if \|klass\| is a boxed primitive type or a sub-class of a boxed primitive type.
	bool IsSubClassOfBoxedPrimitive(const Handle<mirror::Class>& klass)
	REQUIRES_SHARED(Locks::mutator_lock_) {
	StackHandleScope<1> hs(Thread::Current());
	MutableHandle<mirror::Class> h_klass(hs.NewHandle(klass.Get()));
	do {
	Primitive::Type type;
	if (GetUnboxedPrimitiveType(h_klass.Get(), &type)) {
	return true;
	}
	h_klass.Assign(h_klass->GetSuperClass());
	} while (h_klass.Get() != nullptr);
	return false;
	}

	// Unboxed the value \|o\| to \|unboxed_value\| of type \|dst_class\|.
	// \|unboxed_value\| must be zero on entry to avoid dangling pointers.
	// Returns true on success, false if an exception is raised.
	bool UnboxPrimitiveForMethodHandles(ObjPtr<mirror::Object> o,
	ObjPtr<mirror::Class> dst_class,
	JValue* unboxed_value)
	REQUIRES_SHARED(Locks::mutator_lock_) {
	// Check unboxed_value does not contain a dangling pointer.
	DCHECK_EQ(unboxed_value->GetJ(), 0);
	DCHECK(dst_class->IsPrimitive());

	// This is derived from UnboxPrimitive() in reflection.cc, but with
	// exceptions appropriate to method handles.
	if (UNLIKELY(dst_class->GetPrimitiveType() == Primitive::kPrimVoid)) {
	ThrowClassCastException(o->GetClass(), dst_class);
	return false;
	}
	if (UNLIKELY(o == nullptr)) {
	ThrowNullPointerException(
	StringPrintf("Expected to unbox a '%s' primitive type but was returned null",
	dst_class->PrettyDescriptor().c_str()).c_str());
	return false;
	}

	JValue boxed_value;
	ObjPtr<mirror::Class> klass = o->GetClass();
	ObjPtr<mirror::Class> src_class = nullptr;
	ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
	ArtField* primitive_field = &klass->GetIFieldsPtr()->At(0);
	if (klass->DescriptorEquals(kBoxedBooleanClass)) {
	src_class = class_linker->FindPrimitiveClass('Z');
	boxed_value.SetZ(primitive_field->GetBoolean(o));
	} else if (klass->DescriptorEquals(kBoxedByteClass)) {
	src_class = class_linker->FindPrimitiveClass('B');
	boxed_value.SetB(primitive_field->GetByte(o));
	} else if (klass->DescriptorEquals(kBoxedCharacterClass)) {
	src_class = class_linker->FindPrimitiveClass('C');
	boxed_value.SetC(primitive_field->GetChar(o));
	} else if (klass->DescriptorEquals(kBoxedFloatClass)) {
	src_class = class_linker->FindPrimitiveClass('F');
	boxed_value.SetF(primitive_field->GetFloat(o));
	} else if (klass->DescriptorEquals(kBoxedDoubleClass)) {
	src_class = class_linker->FindPrimitiveClass('D');
	boxed_value.SetD(primitive_field->GetDouble(o));
	} else if (klass->DescriptorEquals(kBoxedIntegerClass)) {
	src_class = class_linker->FindPrimitiveClass('I');
	boxed_value.SetI(primitive_field->GetInt(o));
	} else if (klass->DescriptorEquals(kBoxedLongClass)) {
	src_class = class_linker->FindPrimitiveClass('J');
	boxed_value.SetJ(primitive_field->GetLong(o));
	} else if (klass->DescriptorEquals(kBoxedShortClass)) {
	src_class = class_linker->FindPrimitiveClass('S');
	boxed_value.SetS(primitive_field->GetShort(o));
	} else {
	std::string temp;
	ThrowIllegalArgumentException(
	StringPrintf("result has type %s, got %s",
	dst_class->PrettyDescriptor().c_str(),
	PrettyDescriptor(o->GetClass()->GetDescriptor(&temp)).c_str()).c_str());
	return false;
	}

	if (!ConvertPrimitiveValueNoThrow(src_class->GetPrimitiveType(),
	dst_class->GetPrimitiveType(),
	boxed_value,
	unboxed_value)) {
	ThrowClassCastException(src_class, dst_class);
	return false;
	}
	return true;
	}

	inline bool IsReferenceType(Primitive::Type type) {
	return type == Primitive::kPrimNot;
	}

	inline bool IsPrimitiveType(Primitive::Type type) {
	return !IsReferenceType(type);
	}

	} // namespace

	bool ConvertJValueCommon(
	Handle<mirror::MethodType> callsite_type,
	Handle<mirror::MethodType> callee_type,
	ObjPtr<mirror::Class> from,
	ObjPtr<mirror::Class> to,
	JValue* value) {
	// The reader maybe concerned about the safety of the heap object
	// that may be in \|value\|. There is only one case where allocation
	// is obviously needed and that's for boxing. However, in the case
	// of boxing \|value\| contains a non-reference type.

	const Primitive::Type from_type = from->GetPrimitiveType();
	const Primitive::Type to_type = to->GetPrimitiveType();

	// This method must be called only when the types don't match.
	DCHECK(from != to);

	if (IsPrimitiveType(from_type) && IsPrimitiveType(to_type)) {
	// The source and target types are both primitives.
	if (UNLIKELY(!ConvertPrimitiveValueNoThrow(from_type, to_type, *value, value))) {
	ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
	value->SetJ(0);
	return false;
	}
	return true;
	} else if (IsReferenceType(from_type) && IsReferenceType(to_type)) {
	// They're both reference types. If "from" is null, we can pass it
	// through unchanged. If not, we must generate a cast exception if
	// \|to\| is not assignable from the dynamic type of \|ref\|.
	//
	// Playing it safe with StackHandleScope here, not expecting any allocation
	// in mirror::Class::IsAssignable().
	StackHandleScope<2> hs(Thread::Current());
	Handle<mirror::Class> h_to(hs.NewHandle(to));
	Handle<mirror::Object> h_obj(hs.NewHandle(value->GetL()));

	// \|value\| will now be the result value, invalidate its existing value
	// as \|h_obj\| now owns it.
	value->SetJ(0);

	if (h_obj.Get() != nullptr && !to->IsAssignableFrom(h_obj->GetClass())) {
	ThrowClassCastException(h_to.Get(), h_obj->GetClass());
	return false;
	}
	value->SetL(h_obj.Get());
	return true;
	} else if (IsReferenceType(to_type)) {
	DCHECK(IsPrimitiveType(from_type));
	// Playing it safe with StackHandleScope here with regards to
	// GetUnboxedPrimitiveType() and GetBoxedPrimitiveClass().
	StackHandleScope<1> hs(Thread::Current());
	Handle<mirror::Class> h_to(hs.NewHandle(to));
	// The source type is a primitive and the target type is a reference, so we must box.
	// The target type maybe a super class of the boxed source type, for example,
	// if the source type is int, it's boxed type is java.lang.Integer, and the target
	// type could be java.lang.Number.
	Primitive::Type type;
	if (!GetUnboxedPrimitiveType(to, &type)) {
	ObjPtr<mirror::Class> boxed_from_class = GetBoxedPrimitiveClass(from_type);
	if (boxed_from_class->IsSubClass(h_to.Get())) {
	type = from_type;
	} else {
	value->SetJ(0);
	ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
	return false;
	}
	}

	if (UNLIKELY(from_type != type)) {
	value->SetJ(0);
	ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
	return false;
	}

	if (!ConvertPrimitiveValueNoThrow(from_type, type, *value, value)) {
	value->SetJ(0);
	ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
	return false;
	}

	// Then perform the actual boxing, and then set the reference.
	ObjPtr<mirror::Object> boxed = BoxPrimitive(type, *value);
	value->SetL(boxed.Ptr());
	return true;
	} else {
	// The source type is a reference and the target type is a primitive, so we must unbox.
	DCHECK(IsReferenceType(from_type));
	DCHECK(IsPrimitiveType(to_type));

	// Use StackHandleScope to protect \|from\|, \|to\|, and the reference
	// in \|value\| from heap re-arrangements that could be triggered
	// ahead of unboxing step.
	StackHandleScope<3> hs(Thread::Current());
	Handle<mirror::Class> h_to(hs.NewHandle(to));
	Handle<mirror::Class> h_from(hs.NewHandle(from));
	Handle<mirror::Object> h_obj(hs.NewHandle(value->GetL()));

	// \|value\| will now be the result value, invalidate its existing value
	// as \|h_obj\| now owns it.
	value->SetJ(0);

	// Check source type is a boxed primitive or has a boxed primitive super-class.
	ObjPtr<mirror::Class> boxed_to_class = GetBoxedPrimitiveClass(to_type);
	if (!IsSubClassOfBoxedPrimitive(h_from) && !boxed_to_class->IsSubClass(h_from.Get())) {
	ThrowWrongMethodTypeException(callee_type.Get(), callsite_type.Get());
	return false;
	}

	if (h_obj.Get() == nullptr) {
	ThrowNullPointerException(
	StringPrintf("Expected to unbox a '%s' but instance was null",
	h_from->PrettyDescriptor().c_str()).c_str());
	return false;
	}

	return UnboxPrimitiveForMethodHandles(h_obj.Get(), h_to.Get(), value);
	}
	}

	} // namespace art