src/developer/debug/zxdb/expr/resolve_variant.cc

// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/developer/debug/zxdb/expr/resolve_variant.h"

#include <inttypes.h>

#include "src/developer/debug/zxdb/common/ref_ptr_to.h"
#include "src/developer/debug/zxdb/expr/eval_context.h"
#include "src/developer/debug/zxdb/expr/expr_value.h"
#include "src/developer/debug/zxdb/expr/resolve_collection.h"
#include "src/developer/debug/zxdb/symbols/data_member.h"
#include "src/developer/debug/zxdb/symbols/variant.h"
#include "src/developer/debug/zxdb/symbols/variant_part.h"

namespace zxdb {

namespace {

// Gets the active variant for the given value and extracts the single data member inside of it.
// Effectively, this gets the DataMember corresponding to the active value of a Rust enum.
//
// If the value isn't a variant or there isn't a single data member inside of it, returns an error.
// Rust enums currently look like this (this is an Option):
//
//   DW_TAG_structure_type
//     DW_AT_name ("Option<alloc::sync::Arc<fidl::client::ClientInner>>")
//     DW_AT_byte_size (0x08)
//     DW_AT_alignment (8)
//
//     DW_TAG_variant_part
//       // Disciminant (which enum value is active).
//       DW_AT_discr
//       DW_TAG_member  <==== The DW_AT_discr value refers to this record.
//         DW_AT_type (0x0000d042 "u64")
//         DW_AT_alignment (8)
//         DW_AT_data_member_location (0x00)
//         DW_AT_artificial (true)
//
//       // Definition for the "None" variant.
//       DW_TAG_variant
//         DW_AT_discr_value (0x00)
//         DW_TAG_member
//           DW_AT_name ("None")
//           DW_AT_type (Reference to the "None" member structure defined below)
//           DW_AT_alignment (8)
//           DW_AT_data_member_location (0x00)
//
//       // Definition for the "Some" variant. Note this starts at 0 offset which overlaps the
//       // discriminant, but that's OK because the "Some" structure defined below has 8 bytes
//       // of padding at the beginning.
//       DW_TAG_variant
//         DW_TAG_member
//           DW_AT_name ("Some")
//           DW_AT_type (Reference to the "Some" member structure defined below)
//           DW_AT_alignment (8)
//           DW_AT_data_member_location (0x00)
//
//     // Type of data for the contents of the "None" data. This contains no members.
//     DW_TAG_structure_type
//       DW_AT_name ("None")
//       DW_AT_byte_size (0x08)
//       DW_AT_alignment (8)
//       DW_TAG_template_type_parameter
//         DW_AT_type (0x00003d77 "alloc::sync::Arc<fidl::client::ClientInner>")
//         DW_AT_name ("T")
//
//     // Type of data for the contents of the "Some" data.
//     DW_TAG_structure_type
//       DW_AT_name ("Some")
//       DW_AT_byte_size (0x08)
//       DW_AT_alignment (8)
//       DW_TAG_template_type_parameter
//         DW_AT_type (0x00003d77 "alloc::sync::Arc<fidl::client::ClientInner>")
//         DW_AT_name ("T")
//
//       // Actual data of the "Some".
//       DW_TAG_member
//         DW_AT_name ("__0")
//         DW_AT_type (0x00003d77 "alloc::sync::Arc<fidl::client::ClientInner>")
//         DW_AT_alignment (8)
//         DW_AT_data_member_location (0x00)
//
// So this function will return the DW_TAG_member (of either "Some" or "None" structure type) inside
// of the DW_TAG_variant that's active, as indicated by the discriminant.
//
// In the non-error case, this will always return a valid data member (it won't be is_null()).
ErrOr<FoundMember> GetSingleActiveDataMember(const fxl::RefPtr<EvalContext>& context,
                                             const ExprValue& value) {
  fxl::RefPtr<Type> concrete = context->GetConcreteType(value.type());
  if (!concrete)
    return Err("Missing type information.");
  const Collection* collection = concrete->As<Collection>();
  if (!collection)
    return Err("Attempting to extract a variant from a non-collection.");

  const VariantPart* part = collection->variant_part().Get()->As<VariantPart>();
  if (!part)
    return Err("Missing variant part for variant.");

  fxl::RefPtr<Variant> variant;
  if (Err err = ResolveVariant(context, value, collection, part, &variant); err.has_error())
    return err;

  // Extract the one expected data member.
  if (variant->data_members().size() > 1)
    return Err("Expected a single variant data member, got %zu.", variant->data_members().size());
  const DataMember* member = variant->data_members()[0].Get()->As<DataMember>();
  if (!member)
    return Err("Invalid data member in variant symbol.");

  return FoundMember(collection, member);
}

}  // namespace

Err ResolveVariant(const fxl::RefPtr<EvalContext>& context, const ExprValue& value,
                   const Collection* collection, const VariantPart* variant_part,
                   fxl::RefPtr<Variant>* result) {
  // Resolve the discriminant value. It is effectively a member of the enclosing structure.
  const DataMember* discr_member = variant_part->discriminant().Get()->As<DataMember>();
  if (!discr_member)
    return Err("Missing discriminant for variant.");

  // Variants don't have static variant members or virtual inheritance.
  ErrOrValue discr_value =
      ResolveNonstaticMember(context, value, FoundMember(collection, discr_member));
  if (discr_value.has_error())
    return discr_value.err();

  // Expect the discriminant value to resolve to a <= 64-bit number.
  //
  // NOTE: there is some trickery with signed/unsigned values as described in the
  // Variant.discr_value() getter. If we need to support signed discriminants this block will have
  // to be updated.
  uint64_t discr = 0;
  if (Err err = discr_value.value().PromoteTo64(&discr); err.has_error())
    return err;

  // Check against all variants and also look for the default variant.
  const Variant* default_var = nullptr;
  for (const auto& lazy_var : variant_part->variants()) {
    const Variant* var = lazy_var.Get()->As<Variant>();
    if (!var)
      continue;

    if (var->discr_value()) {
      if (*var->discr_value() == discr) {
        // Found match.
        *result = RefPtrTo(var);
        return Err();
      }
    } else {
      // No discriminant value set on the variant means it's the default one.
      default_var = var;
    }
  }

  // No match means use the default value if there is one.
  if (default_var) {
    *result = RefPtrTo(default_var);
    return Err();
  }

  return Err("Discriminant value of 0x%" PRIx64 " does not match any of the Variants.", discr);
}

ErrOr<std::string> GetActiveRustVariantName(const fxl::RefPtr<EvalContext>& context,
                                            const ExprValue& value) {
  ErrOr<FoundMember> found_member = GetSingleActiveDataMember(context, value);
  if (found_member.has_error())
    return found_member.err();
  FX_DCHECK(!found_member.value().is_null());  // Should always be valid in non-error cases.

  // The name of the enum in Rust is the name of the data member.
  return found_member.value().data_member()->GetAssignedName();
}

ErrOrValue ResolveSingleVariantValue(const fxl::RefPtr<EvalContext>& context,
                                     const ExprValue& value,
                                     fxl::RefPtr<DataMember>* member_to_return) {
  fxl::RefPtr<Type> concrete = context->GetConcreteType(value.type());
  if (!concrete)
    return Err("Missing type information.");
  const Collection* collection = concrete->As<Collection>();
  if (!collection)
    return Err("Attempting to extract a variant from a non-collection.");

  const VariantPart* part = collection->variant_part().Get()->As<VariantPart>();
  if (!part)
    return Err("Missing variant part for variant.");

  fxl::RefPtr<Variant> variant;
  if (Err err = ResolveVariant(context, value, collection, part, &variant); err.has_error())
    return err;

  if (variant->data_members().empty())
    return ExprValue();  // Allow empty.

  // Extract the one expected data member.
  if (variant->data_members().size() > 1)
    return Err("Expected a single variant data member, got %zu.", variant->data_members().size());
  const DataMember* member = variant->data_members()[0].Get()->As<DataMember>();
  if (!member)
    return Err("Invalid data member in variant symbol.");

  if (member_to_return)
    *member_to_return = RefPtrTo(member);

  return ResolveNonstaticMember(context, value, FoundMember(collection, member));
}

}  // namespace zxdb