runtime/lambda/closure.cc - platform/art - Git at Google

 /*
  * Copyright (C) 2015 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 "lambda/closure.h"

 #include "base/logging.h"
 #include "lambda/art_lambda_method.h"
 #include "runtime/mirror/object_reference.h"

 static constexpr const bool kClosureSupportsReferences = false;
 static constexpr const bool kClosureSupportsGarbageCollection = false;

 namespace art {
 namespace lambda {

 template <typename T>
 // TODO: can I return T __attribute__((__aligned__(1)))* here instead?
 const uint8_t* Closure::GetUnsafeAtOffset(size_t offset) const {
   // Do not DCHECK here with existing helpers since most of them will call into this function.
   return reinterpret_cast<const uint8_t*>(captured_) + offset;
 }

 size_t Closure::GetCapturedVariableSize(ShortyFieldType variable_type, size_t offset) const {
   switch (variable_type) {
     case ShortyFieldType::kLambda:
     {
       return GetClosureSize(GetUnsafeAtOffset<Closure>(offset));
     }
     default:
       DCHECK(variable_type.IsStaticSize());
       return variable_type.GetStaticSize();
   }
 }

 // Templatize the flags to give the compiler a fighting chance to eliminate
 // any unnecessary code through different uses of this function.
 template <Closure::VariableInfo::Flags flags>
 inline Closure::VariableInfo Closure::ParseTypeDescriptor(const char* type_descriptor,
                                                           size_t upto_index) const {
   DCHECK(type_descriptor != nullptr);

   VariableInfo result;

   ShortyFieldType last_type;
   size_t offset = (flags & VariableInfo::kOffset) ? GetStartingOffset() : 0;
   size_t prev_offset = 0;
   size_t count = 0;

   while ((type_descriptor =
       ShortyFieldType::ParseFromFieldTypeDescriptor(type_descriptor, &last_type)) != nullptr) {
     count++;

     if (flags & VariableInfo::kOffset) {
       // Accumulate the sizes of all preceding captured variables as the current offset only.
       offset += prev_offset;
       prev_offset = GetCapturedVariableSize(last_type, offset);
     }

     if ((count > upto_index)) {
       break;
     }
   }

   if (flags & VariableInfo::kVariableType) {
     result.variable_type_ = last_type;
   }

   if (flags & VariableInfo::kIndex) {
     result.index_ = count;
   }

   if (flags & VariableInfo::kCount) {
     result.count_ = count;
   }

   if (flags & VariableInfo::kOffset) {
     result.offset_ = offset;
   }

   // TODO: We should probably store the result of this in the ArtLambdaMethod,
   // to avoid re-computing the data every single time for static closures.
   return result;
 }

 size_t Closure::GetCapturedVariablesSize() const {
   const size_t captured_variable_offset = offsetof(Closure, captured_);
   DCHECK_GE(GetSize(), captured_variable_offset);  // Prevent underflows.
   return GetSize() - captured_variable_offset;
 }

 size_t Closure::GetSize() const {
   const size_t static_closure_size = lambda_info_->GetStaticClosureSize();
   if (LIKELY(lambda_info_->IsStaticSize())) {
     return static_closure_size;
   }

   DCHECK_GE(static_closure_size, sizeof(captured_[0].dynamic_.size_));
   const size_t dynamic_closure_size = captured_[0].dynamic_.size_;
   // The dynamic size better be at least as big as the static size.
   DCHECK_GE(dynamic_closure_size, static_closure_size);

   return dynamic_closure_size;
 }

 void Closure::CopyTo(void* target, size_t target_size) const {
   DCHECK_GE(target_size, GetSize());

   // TODO: using memcpy is unsafe with read barriers, fix this once we add reference support
   static_assert(kClosureSupportsReferences == false,
                 "Do not use memcpy with readbarrier references");
   memcpy(target, this, GetSize());
 }

 ArtMethod* Closure::GetTargetMethod() const {
   return const_cast<ArtMethod*>(lambda_info_->GetArtMethod());
 }

 uint32_t Closure::GetHashCode() const {
   // Start with a non-zero constant, a prime number.
   uint32_t result = 17;

   // Include the hash with the ArtMethod.
   {
     uintptr_t method = reinterpret_cast<uintptr_t>(GetTargetMethod());
     result = 31 * result + Low32Bits(method);
     if (sizeof(method) == sizeof(uint64_t)) {
       result = 31 * result + High32Bits(method);
     }
   }

   // Include a hash for each captured variable.
   for (size_t i = 0; i < GetCapturedVariablesSize(); ++i) {
     // TODO: not safe for GC-able values since the address can move and the hash code would change.
     uint8_t captured_variable_raw_value;
     CopyUnsafeAtOffset<uint8_t>(i, /*out*/&captured_variable_raw_value);  // NOLINT: [whitespace/comma] [3]

     result = 31 * result + captured_variable_raw_value;
   }

   // TODO: Fix above loop to work for objects and lambdas.
   static_assert(kClosureSupportsGarbageCollection == false,
                "Need to update above loop to read the hash code from the "
                 "objects and lambdas recursively");

   return result;
 }

 bool Closure::ReferenceEquals(const Closure* other) const {
   DCHECK(other != nullptr);

   // TODO: Need rework to use read barriers once closures have references inside of them that can
   // move. Until then, it's safe to just compare the data inside of it directly.
   static_assert(kClosureSupportsReferences == false,
                 "Unsafe to use memcmp in read barrier collector");

   if (GetSize() != other->GetSize()) {
     return false;
   }

   return memcmp(this, other, GetSize());
 }

 size_t Closure::GetNumberOfCapturedVariables() const {
   // TODO: refactor into art_lambda_method.h. Parsing should only be required here as a DCHECK.
   VariableInfo variable_info =
       ParseTypeDescriptor<VariableInfo::kCount>(GetCapturedVariablesTypeDescriptor(),
                                                 VariableInfo::kUpToIndexMax);
   size_t count = variable_info.count_;
   // Assuming each variable was 1 byte, the size should always be greater or equal than the count.
   DCHECK_LE(count, GetCapturedVariablesSize());
   return count;
 }

 const char* Closure::GetCapturedVariablesTypeDescriptor() const {
   return lambda_info_->GetCapturedVariablesTypeDescriptor();
 }

 ShortyFieldType Closure::GetCapturedShortyType(size_t index) const {
   DCHECK_LT(index, GetNumberOfCapturedVariables());

   VariableInfo variable_info =
       ParseTypeDescriptor<VariableInfo::kVariableType>(GetCapturedVariablesTypeDescriptor(),
                                                        index);

   return variable_info.variable_type_;
 }

 uint32_t Closure::GetCapturedPrimitiveNarrow(size_t index) const {
   DCHECK(GetCapturedShortyType(index).IsPrimitiveNarrow());

   ShortyFieldType variable_type;
   size_t offset;
   GetCapturedVariableTypeAndOffset(index, &variable_type, &offset);

   // TODO: Restructure to use template specialization, e.g. GetCapturedPrimitive<T>
   // so that we can avoid this nonsense regarding memcpy always overflowing.
   // Plus, this additional switching seems redundant since the interpreter
   // would've done it already, and knows the exact type.
   uint32_t result = 0;
   static_assert(ShortyFieldTypeTraits::IsPrimitiveNarrowType<decltype(result)>(),
                 "result must be a primitive narrow type");
   switch (variable_type) {
     case ShortyFieldType::kBoolean:
       CopyUnsafeAtOffset<bool>(offset, &result);
       break;
     case ShortyFieldType::kByte:
       CopyUnsafeAtOffset<uint8_t>(offset, &result);
       break;
     case ShortyFieldType::kChar:
       CopyUnsafeAtOffset<uint16_t>(offset, &result);
       break;
     case ShortyFieldType::kShort:
       CopyUnsafeAtOffset<int16_t>(offset, &result);
       break;
     case ShortyFieldType::kInt:
       CopyUnsafeAtOffset<int32_t>(offset, &result);
       break;
     case ShortyFieldType::kFloat:
       // XX: Maybe there should just be a GetCapturedPrimitive<T> to avoid this shuffle?
       // The interpreter's invoke seems to only special case references and wides,
       // everything else is treated as a generic 32-bit pattern.
       CopyUnsafeAtOffset<float>(offset, &result);
       break;
     default:
       LOG(FATAL)
           << "expected a valid narrow primitive shorty type but got "
           << static_cast<char>(variable_type);
       UNREACHABLE();
   }

   return result;
 }

 uint64_t Closure::GetCapturedPrimitiveWide(size_t index) const {
   DCHECK(GetCapturedShortyType(index).IsPrimitiveWide());

   ShortyFieldType variable_type;
   size_t offset;
   GetCapturedVariableTypeAndOffset(index, &variable_type, &offset);

   // TODO: Restructure to use template specialization, e.g. GetCapturedPrimitive<T>
   // so that we can avoid this nonsense regarding memcpy always overflowing.
   // Plus, this additional switching seems redundant since the interpreter
   // would've done it already, and knows the exact type.
   uint64_t result = 0;
   static_assert(ShortyFieldTypeTraits::IsPrimitiveWideType<decltype(result)>(),
                 "result must be a primitive wide type");
   switch (variable_type) {
     case ShortyFieldType::kLong:
       CopyUnsafeAtOffset<int64_t>(offset, &result);
       break;
     case ShortyFieldType::kDouble:
       CopyUnsafeAtOffset<double>(offset, &result);
       break;
     default:
       LOG(FATAL)
           << "expected a valid primitive wide shorty type but got "
           << static_cast<char>(variable_type);
       UNREACHABLE();
   }

   return result;
 }

 mirror::Object* Closure::GetCapturedObject(size_t index) const {
   DCHECK(GetCapturedShortyType(index).IsObject());

   ShortyFieldType variable_type;
   size_t offset;
   GetCapturedVariableTypeAndOffset(index, &variable_type, &offset);

   // TODO: Restructure to use template specialization, e.g. GetCapturedPrimitive<T>
   // so that we can avoid this nonsense regarding memcpy always overflowing.
   // Plus, this additional switching seems redundant since the interpreter
   // would've done it already, and knows the exact type.
   mirror::Object* result = nullptr;
   static_assert(ShortyFieldTypeTraits::IsObjectType<decltype(result)>(),
                 "result must be an object type");
   switch (variable_type) {
     case ShortyFieldType::kObject:
       // TODO: This seems unsafe. This may need to use gcroots.
       static_assert(kClosureSupportsGarbageCollection == false,
                     "May need GcRoots and definitely need mutator locks");
       {
         mirror::CompressedReference<mirror::Object> compressed_result;
         CopyUnsafeAtOffset<uint32_t>(offset, &compressed_result);
         result = compressed_result.AsMirrorPtr();
       }
       break;
     default:
       CHECK(false)
           << "expected a valid shorty type but got " << static_cast<char>(variable_type);
       UNREACHABLE();
   }

   return result;
 }

 size_t Closure::GetCapturedClosureSize(size_t index) const {
   DCHECK(GetCapturedShortyType(index).IsLambda());
   size_t offset = GetCapturedVariableOffset(index);

   auto* captured_ptr = reinterpret_cast<const uint8_t*>(&captured_);
   size_t closure_size = GetClosureSize(captured_ptr + offset);

   return closure_size;
 }

 void Closure::CopyCapturedClosure(size_t index, void* destination, size_t destination_room) const {
   DCHECK(GetCapturedShortyType(index).IsLambda());
   size_t offset = GetCapturedVariableOffset(index);

   auto* captured_ptr = reinterpret_cast<const uint8_t*>(&captured_);
   size_t closure_size = GetClosureSize(captured_ptr + offset);

   static_assert(ShortyFieldTypeTraits::IsLambdaType<Closure*>(),
                 "result must be a lambda type");

   CopyUnsafeAtOffset<Closure>(offset, destination, closure_size, destination_room);
 }

 size_t Closure::GetCapturedVariableOffset(size_t index) const {
   VariableInfo variable_info =
       ParseTypeDescriptor<VariableInfo::kOffset>(GetCapturedVariablesTypeDescriptor(),
                                                  index);

   size_t offset = variable_info.offset_;

   return offset;
 }

 void Closure::GetCapturedVariableTypeAndOffset(size_t index,
                                                ShortyFieldType* out_type,
                                                size_t* out_offset) const {
   DCHECK(out_type != nullptr);
   DCHECK(out_offset != nullptr);

   static constexpr const VariableInfo::Flags kVariableTypeAndOffset =
       static_cast<VariableInfo::Flags>(VariableInfo::kVariableType | VariableInfo::kOffset);
   VariableInfo variable_info =
       ParseTypeDescriptor<kVariableTypeAndOffset>(GetCapturedVariablesTypeDescriptor(),
                                                   index);

   ShortyFieldType variable_type = variable_info.variable_type_;
   size_t offset = variable_info.offset_;

   *out_type = variable_type;
   *out_offset = offset;
 }

 template <typename T>
 void Closure::CopyUnsafeAtOffset(size_t offset,
                                  void* destination,
                                  size_t src_size,
                                  size_t destination_room) const {
   DCHECK_GE(destination_room, src_size);
   const uint8_t* data_ptr = GetUnsafeAtOffset<T>(offset);
   memcpy(destination, data_ptr, sizeof(T));
 }

 // TODO: This is kind of ugly. I would prefer an unaligned_ptr<Closure> here.
 // Unfortunately C++ doesn't let you lower the alignment (i.e. alignas(1) Closure*) is not legal.
 size_t Closure::GetClosureSize(const uint8_t* closure) {
   DCHECK(closure != nullptr);

   static_assert(!std::is_base_of<mirror::Object, Closure>::value,
                 "It might be unsafe to call memcpy on a managed object");

   // Safe as long as it's not a mirror Object.
   // TODO: Should probably wrap this in like MemCpyNative or some such which statically asserts
   // we aren't trying to copy mirror::Object data around.
   ArtLambdaMethod* closure_info;
   memcpy(&closure_info, closure + offsetof(Closure, lambda_info_), sizeof(closure_info));

   if (LIKELY(closure_info->IsStaticSize())) {
     return closure_info->GetStaticClosureSize();
   }

   // The size is dynamic, so we need to read it from captured_variables_ portion.
   size_t dynamic_size;
   memcpy(&dynamic_size,
          closure + offsetof(Closure, captured_[0].dynamic_.size_),
          sizeof(dynamic_size));
   static_assert(sizeof(dynamic_size) == sizeof(captured_[0].dynamic_.size_),
                 "Dynamic size type must match the structural type of the size");

   DCHECK_GE(dynamic_size, closure_info->GetStaticClosureSize());
   return dynamic_size;
 }

 size_t Closure::GetStartingOffset() const {
   static constexpr const size_t captured_offset = offsetof(Closure, captured_);
   if (LIKELY(lambda_info_->IsStaticSize())) {
     return offsetof(Closure, captured_[0].static_variables_) - captured_offset;
   } else {
     return offsetof(Closure, captured_[0].dynamic_.variables_) - captured_offset;
   }
 }

 }  // namespace lambda
 }  // namespace art
	/*
	* Copyright (C) 2015 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 "lambda/closure.h"

	#include "base/logging.h"
	#include "lambda/art_lambda_method.h"
	#include "runtime/mirror/object_reference.h"

	static constexpr const bool kClosureSupportsReferences = false;
	static constexpr const bool kClosureSupportsGarbageCollection = false;

	namespace art {
	namespace lambda {

	template <typename T>
	// TODO: can I return T __attribute__((__aligned__(1)))* here instead?
	const uint8_t* Closure::GetUnsafeAtOffset(size_t offset) const {
	// Do not DCHECK here with existing helpers since most of them will call into this function.
	return reinterpret_cast<const uint8_t*>(captured_) + offset;
	}

	size_t Closure::GetCapturedVariableSize(ShortyFieldType variable_type, size_t offset) const {
	switch (variable_type) {
	case ShortyFieldType::kLambda:
	{
	return GetClosureSize(GetUnsafeAtOffset<Closure>(offset));
	}
	default:
	DCHECK(variable_type.IsStaticSize());
	return variable_type.GetStaticSize();
	}
	}

	// Templatize the flags to give the compiler a fighting chance to eliminate
	// any unnecessary code through different uses of this function.
	template <Closure::VariableInfo::Flags flags>
	inline Closure::VariableInfo Closure::ParseTypeDescriptor(const char* type_descriptor,
	size_t upto_index) const {
	DCHECK(type_descriptor != nullptr);

	VariableInfo result;

	ShortyFieldType last_type;
	size_t offset = (flags & VariableInfo::kOffset) ? GetStartingOffset() : 0;
	size_t prev_offset = 0;
	size_t count = 0;

	while ((type_descriptor =
	ShortyFieldType::ParseFromFieldTypeDescriptor(type_descriptor, &last_type)) != nullptr) {
	count++;

	if (flags & VariableInfo::kOffset) {
	// Accumulate the sizes of all preceding captured variables as the current offset only.
	offset += prev_offset;
	prev_offset = GetCapturedVariableSize(last_type, offset);
	}

	if ((count > upto_index)) {
	break;
	}
	}

	if (flags & VariableInfo::kVariableType) {
	result.variable_type_ = last_type;
	}

	if (flags & VariableInfo::kIndex) {
	result.index_ = count;
	}

	if (flags & VariableInfo::kCount) {
	result.count_ = count;
	}

	if (flags & VariableInfo::kOffset) {
	result.offset_ = offset;
	}

	// TODO: We should probably store the result of this in the ArtLambdaMethod,
	// to avoid re-computing the data every single time for static closures.
	return result;
	}

	size_t Closure::GetCapturedVariablesSize() const {
	const size_t captured_variable_offset = offsetof(Closure, captured_);
	DCHECK_GE(GetSize(), captured_variable_offset); // Prevent underflows.
	return GetSize() - captured_variable_offset;
	}

	size_t Closure::GetSize() const {
	const size_t static_closure_size = lambda_info_->GetStaticClosureSize();
	if (LIKELY(lambda_info_->IsStaticSize())) {
	return static_closure_size;
	}

	DCHECK_GE(static_closure_size, sizeof(captured_[0].dynamic_.size_));
	const size_t dynamic_closure_size = captured_[0].dynamic_.size_;
	// The dynamic size better be at least as big as the static size.
	DCHECK_GE(dynamic_closure_size, static_closure_size);

	return dynamic_closure_size;
	}

	void Closure::CopyTo(void* target, size_t target_size) const {
	DCHECK_GE(target_size, GetSize());

	// TODO: using memcpy is unsafe with read barriers, fix this once we add reference support
	static_assert(kClosureSupportsReferences == false,
	"Do not use memcpy with readbarrier references");
	memcpy(target, this, GetSize());
	}

	ArtMethod* Closure::GetTargetMethod() const {
	return const_cast<ArtMethod*>(lambda_info_->GetArtMethod());
	}

	uint32_t Closure::GetHashCode() const {
	// Start with a non-zero constant, a prime number.
	uint32_t result = 17;

	// Include the hash with the ArtMethod.
	{
	uintptr_t method = reinterpret_cast<uintptr_t>(GetTargetMethod());
	result = 31 * result + Low32Bits(method);
	if (sizeof(method) == sizeof(uint64_t)) {
	result = 31 * result + High32Bits(method);
	}
	}

	// Include a hash for each captured variable.
	for (size_t i = 0; i < GetCapturedVariablesSize(); ++i) {
	// TODO: not safe for GC-able values since the address can move and the hash code would change.
	uint8_t captured_variable_raw_value;
	CopyUnsafeAtOffset<uint8_t>(i, /out/&captured_variable_raw_value); // NOLINT: [whitespace/comma] [3]

	result = 31 * result + captured_variable_raw_value;
	}

	// TODO: Fix above loop to work for objects and lambdas.
	static_assert(kClosureSupportsGarbageCollection == false,
	"Need to update above loop to read the hash code from the "
	"objects and lambdas recursively");

	return result;
	}

	bool Closure::ReferenceEquals(const Closure* other) const {
	DCHECK(other != nullptr);

	// TODO: Need rework to use read barriers once closures have references inside of them that can
	// move. Until then, it's safe to just compare the data inside of it directly.
	static_assert(kClosureSupportsReferences == false,
	"Unsafe to use memcmp in read barrier collector");

	if (GetSize() != other->GetSize()) {
	return false;
	}

	return memcmp(this, other, GetSize());
	}

	size_t Closure::GetNumberOfCapturedVariables() const {
	// TODO: refactor into art_lambda_method.h. Parsing should only be required here as a DCHECK.
	VariableInfo variable_info =
	ParseTypeDescriptor<VariableInfo::kCount>(GetCapturedVariablesTypeDescriptor(),
	VariableInfo::kUpToIndexMax);
	size_t count = variable_info.count_;
	// Assuming each variable was 1 byte, the size should always be greater or equal than the count.
	DCHECK_LE(count, GetCapturedVariablesSize());
	return count;
	}

	const char* Closure::GetCapturedVariablesTypeDescriptor() const {
	return lambda_info_->GetCapturedVariablesTypeDescriptor();
	}

	ShortyFieldType Closure::GetCapturedShortyType(size_t index) const {
	DCHECK_LT(index, GetNumberOfCapturedVariables());

	VariableInfo variable_info =
	ParseTypeDescriptor<VariableInfo::kVariableType>(GetCapturedVariablesTypeDescriptor(),
	index);

	return variable_info.variable_type_;
	}

	uint32_t Closure::GetCapturedPrimitiveNarrow(size_t index) const {
	DCHECK(GetCapturedShortyType(index).IsPrimitiveNarrow());

	ShortyFieldType variable_type;
	size_t offset;
	GetCapturedVariableTypeAndOffset(index, &variable_type, &offset);

	// TODO: Restructure to use template specialization, e.g. GetCapturedPrimitive<T>
	// so that we can avoid this nonsense regarding memcpy always overflowing.
	// Plus, this additional switching seems redundant since the interpreter
	// would've done it already, and knows the exact type.
	uint32_t result = 0;
	static_assert(ShortyFieldTypeTraits::IsPrimitiveNarrowType<decltype(result)>(),
	"result must be a primitive narrow type");
	switch (variable_type) {
	case ShortyFieldType::kBoolean:
	CopyUnsafeAtOffset<bool>(offset, &result);
	break;
	case ShortyFieldType::kByte:
	CopyUnsafeAtOffset<uint8_t>(offset, &result);
	break;
	case ShortyFieldType::kChar:
	CopyUnsafeAtOffset<uint16_t>(offset, &result);
	break;
	case ShortyFieldType::kShort:
	CopyUnsafeAtOffset<int16_t>(offset, &result);
	break;
	case ShortyFieldType::kInt:
	CopyUnsafeAtOffset<int32_t>(offset, &result);
	break;
	case ShortyFieldType::kFloat:
	// XX: Maybe there should just be a GetCapturedPrimitive<T> to avoid this shuffle?
	// The interpreter's invoke seems to only special case references and wides,
	// everything else is treated as a generic 32-bit pattern.
	CopyUnsafeAtOffset<float>(offset, &result);
	break;
	default:
	LOG(FATAL)
	<< "expected a valid narrow primitive shorty type but got "
	<< static_cast<char>(variable_type);
	UNREACHABLE();
	}

	return result;
	}

	uint64_t Closure::GetCapturedPrimitiveWide(size_t index) const {
	DCHECK(GetCapturedShortyType(index).IsPrimitiveWide());

	ShortyFieldType variable_type;
	size_t offset;
	GetCapturedVariableTypeAndOffset(index, &variable_type, &offset);

	// TODO: Restructure to use template specialization, e.g. GetCapturedPrimitive<T>
	// so that we can avoid this nonsense regarding memcpy always overflowing.
	// Plus, this additional switching seems redundant since the interpreter
	// would've done it already, and knows the exact type.
	uint64_t result = 0;
	static_assert(ShortyFieldTypeTraits::IsPrimitiveWideType<decltype(result)>(),
	"result must be a primitive wide type");
	switch (variable_type) {
	case ShortyFieldType::kLong:
	CopyUnsafeAtOffset<int64_t>(offset, &result);
	break;
	case ShortyFieldType::kDouble:
	CopyUnsafeAtOffset<double>(offset, &result);
	break;
	default:
	LOG(FATAL)
	<< "expected a valid primitive wide shorty type but got "
	<< static_cast<char>(variable_type);
	UNREACHABLE();
	}

	return result;
	}

	mirror::Object* Closure::GetCapturedObject(size_t index) const {
	DCHECK(GetCapturedShortyType(index).IsObject());

	ShortyFieldType variable_type;
	size_t offset;
	GetCapturedVariableTypeAndOffset(index, &variable_type, &offset);

	// TODO: Restructure to use template specialization, e.g. GetCapturedPrimitive<T>
	// so that we can avoid this nonsense regarding memcpy always overflowing.
	// Plus, this additional switching seems redundant since the interpreter
	// would've done it already, and knows the exact type.
	mirror::Object* result = nullptr;
	static_assert(ShortyFieldTypeTraits::IsObjectType<decltype(result)>(),
	"result must be an object type");
	switch (variable_type) {
	case ShortyFieldType::kObject:
	// TODO: This seems unsafe. This may need to use gcroots.
	static_assert(kClosureSupportsGarbageCollection == false,
	"May need GcRoots and definitely need mutator locks");
	{
	mirror::CompressedReference<mirror::Object> compressed_result;
	CopyUnsafeAtOffset<uint32_t>(offset, &compressed_result);
	result = compressed_result.AsMirrorPtr();
	}
	break;
	default:
	CHECK(false)
	<< "expected a valid shorty type but got " << static_cast<char>(variable_type);
	UNREACHABLE();
	}

	return result;
	}

	size_t Closure::GetCapturedClosureSize(size_t index) const {
	DCHECK(GetCapturedShortyType(index).IsLambda());
	size_t offset = GetCapturedVariableOffset(index);

	auto* captured_ptr = reinterpret_cast<const uint8_t*>(&captured_);
	size_t closure_size = GetClosureSize(captured_ptr + offset);

	return closure_size;
	}

	void Closure::CopyCapturedClosure(size_t index, void* destination, size_t destination_room) const {
	DCHECK(GetCapturedShortyType(index).IsLambda());
	size_t offset = GetCapturedVariableOffset(index);

	auto* captured_ptr = reinterpret_cast<const uint8_t*>(&captured_);
	size_t closure_size = GetClosureSize(captured_ptr + offset);

	static_assert(ShortyFieldTypeTraits::IsLambdaType<Closure*>(),
	"result must be a lambda type");

	CopyUnsafeAtOffset<Closure>(offset, destination, closure_size, destination_room);
	}

	size_t Closure::GetCapturedVariableOffset(size_t index) const {
	VariableInfo variable_info =
	ParseTypeDescriptor<VariableInfo::kOffset>(GetCapturedVariablesTypeDescriptor(),
	index);

	size_t offset = variable_info.offset_;

	return offset;
	}

	void Closure::GetCapturedVariableTypeAndOffset(size_t index,
	ShortyFieldType* out_type,
	size_t* out_offset) const {
	DCHECK(out_type != nullptr);
	DCHECK(out_offset != nullptr);

	static constexpr const VariableInfo::Flags kVariableTypeAndOffset =
	static_cast<VariableInfo::Flags>(VariableInfo::kVariableType \| VariableInfo::kOffset);
	VariableInfo variable_info =
	ParseTypeDescriptor<kVariableTypeAndOffset>(GetCapturedVariablesTypeDescriptor(),
	index);

	ShortyFieldType variable_type = variable_info.variable_type_;
	size_t offset = variable_info.offset_;

	*out_type = variable_type;
	*out_offset = offset;
	}

	template <typename T>
	void Closure::CopyUnsafeAtOffset(size_t offset,
	void* destination,
	size_t src_size,
	size_t destination_room) const {
	DCHECK_GE(destination_room, src_size);
	const uint8_t* data_ptr = GetUnsafeAtOffset<T>(offset);
	memcpy(destination, data_ptr, sizeof(T));
	}

	// TODO: This is kind of ugly. I would prefer an unaligned_ptr<Closure> here.
	// Unfortunately C++ doesn't let you lower the alignment (i.e. alignas(1) Closure*) is not legal.
	size_t Closure::GetClosureSize(const uint8_t* closure) {
	DCHECK(closure != nullptr);

	static_assert(!std::is_base_of<mirror::Object, Closure>::value,
	"It might be unsafe to call memcpy on a managed object");

	// Safe as long as it's not a mirror Object.
	// TODO: Should probably wrap this in like MemCpyNative or some such which statically asserts
	// we aren't trying to copy mirror::Object data around.
	ArtLambdaMethod* closure_info;
	memcpy(&closure_info, closure + offsetof(Closure, lambda_info_), sizeof(closure_info));

	if (LIKELY(closure_info->IsStaticSize())) {
	return closure_info->GetStaticClosureSize();
	}

	// The size is dynamic, so we need to read it from captured_variables_ portion.
	size_t dynamic_size;
	memcpy(&dynamic_size,
	closure + offsetof(Closure, captured_[0].dynamic_.size_),
	sizeof(dynamic_size));
	static_assert(sizeof(dynamic_size) == sizeof(captured_[0].dynamic_.size_),
	"Dynamic size type must match the structural type of the size");

	DCHECK_GE(dynamic_size, closure_info->GetStaticClosureSize());
	return dynamic_size;
	}

	size_t Closure::GetStartingOffset() const {
	static constexpr const size_t captured_offset = offsetof(Closure, captured_);
	if (LIKELY(lambda_info_->IsStaticSize())) {
	return offsetof(Closure, captured_[0].static_variables_) - captured_offset;
	} else {
	return offsetof(Closure, captured_[0].dynamic_.variables_) - captured_offset;
	}
	}

	} // namespace lambda
	} // namespace art