runtime/lambda/closure.cc

/*
 * 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