ABIWindows_x86_64.cpp

Go to the documentation of this file.

//===-- ABIWindows_x86_64.cpp ---------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "ABIWindows_x86_64.h"
 
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/TargetParser/Triple.h"
 
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/Value.h"
#include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/RegisterValue.h"
#include "lldb/Utility/Status.h"
#include "lldb/ValueObject/ValueObjectConstResult.h"
#include "lldb/ValueObject/ValueObjectMemory.h"
#include "lldb/ValueObject/ValueObjectRegister.h"
#include <optional>
 
using namespace lldb;
using namespace lldb_private;
 
LLDB_PLUGIN_DEFINE(ABIWindows_x86_64)
 
enum dwarf_regnums {
  dwarf_rax = 0,
  dwarf_rdx,
  dwarf_rcx,
  dwarf_rbx,
  dwarf_rsi,
  dwarf_rdi,
  dwarf_rbp,
  dwarf_rsp,
  dwarf_r8,
  dwarf_r9,
  dwarf_r10,
  dwarf_r11,
  dwarf_r12,
  dwarf_r13,
  dwarf_r14,
  dwarf_r15,
  dwarf_rip,
  dwarf_xmm0,
  dwarf_xmm1,
  dwarf_xmm2,
  dwarf_xmm3,
  dwarf_xmm4,
  dwarf_xmm5,
  dwarf_xmm6,
  dwarf_xmm7,
  dwarf_xmm8,
  dwarf_xmm9,
  dwarf_xmm10,
  dwarf_xmm11,
  dwarf_xmm12,
  dwarf_xmm13,
  dwarf_xmm14,
  dwarf_xmm15,
  dwarf_stmm0,
  dwarf_stmm1,
  dwarf_stmm2,
  dwarf_stmm3,
  dwarf_stmm4,
  dwarf_stmm5,
  dwarf_stmm6,
  dwarf_stmm7,
  dwarf_ymm0,
  dwarf_ymm1,
  dwarf_ymm2,
  dwarf_ymm3,
  dwarf_ymm4,
  dwarf_ymm5,
  dwarf_ymm6,
  dwarf_ymm7,
  dwarf_ymm8,
  dwarf_ymm9,
  dwarf_ymm10,
  dwarf_ymm11,
  dwarf_ymm12,
  dwarf_ymm13,
  dwarf_ymm14,
  dwarf_ymm15,
  dwarf_bnd0 = 126,
  dwarf_bnd1,
  dwarf_bnd2,
  dwarf_bnd3
};
 
bool ABIWindows_x86_64::GetPointerReturnRegister(const char *&name) {
  name = "rax";
  return true;
}
 
size_t ABIWindows_x86_64::GetRedZoneSize() const { return 0; }
 
//------------------------------------------------------------------
// Static Functions
//------------------------------------------------------------------
 
ABISP
ABIWindows_x86_64::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
  if (arch.GetTriple().getArch() == llvm::Triple::x86_64 &&
      arch.GetTriple().isOSWindows()) {
    return ABISP(
        new ABIWindows_x86_64(std::move(process_sp), MakeMCRegisterInfo(arch)));
  }
  return ABISP();
}
 
bool ABIWindows_x86_64::PrepareTrivialCall(Thread &thread, addr_t sp,
                                           addr_t func_addr, addr_t return_addr,
                                           llvm::ArrayRef<addr_t> args) const {
  Log *log = GetLog(LLDBLog::Expressions);
 
  if (log) {
    StreamString s;
    s.Printf("ABIWindows_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
             ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
             ", return_addr = 0x%" PRIx64,
             thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
             (uint64_t)return_addr);
 
    for (size_t i = 0; i < args.size(); ++i)
      s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1),
               args[i]);
    s.PutCString(")");
    log->PutString(s.GetString());
  }
 
  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
  if (!reg_ctx)
    return false;
 
  const RegisterInfo *reg_info = nullptr;
 
  if (args.size() > 4) // Windows x64 only put first 4 arguments into registers
    return false;
 
  for (size_t i = 0; i < args.size(); ++i) {
    reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
                                        LLDB_REGNUM_GENERIC_ARG1 + i);
    LLDB_LOGF(log, "About to write arg%" PRIu64 " (0x%" PRIx64 ") into %s",
              static_cast<uint64_t>(i + 1), args[i], reg_info->name);
    if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
      return false;
  }
 
  // First, align the SP
 
  LLDB_LOGF(log, "16-byte aligning SP: 0x%" PRIx64 " to 0x%" PRIx64,
            (uint64_t)sp, (uint64_t)(sp & ~0xfull));
 
  sp &= ~(0xfull); // 16-byte alignment
 
  sp -= 8; // return address
 
  Status error;
  const RegisterInfo *pc_reg_info =
      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
  const RegisterInfo *sp_reg_info =
      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
  ProcessSP process_sp(thread.GetProcess());
 
  RegisterValue reg_value;
  LLDB_LOGF(log,
            "Pushing the return address onto the stack: 0x%" PRIx64
            ": 0x%" PRIx64,
            (uint64_t)sp, (uint64_t)return_addr);
 
  // Save return address onto the stack
  if (!process_sp->WritePointerToMemory(sp, return_addr, error))
    return false;
 
  // %rsp is set to the actual stack value.
 
  LLDB_LOGF(log, "Writing SP: 0x%" PRIx64, (uint64_t)sp);
 
  if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_info, sp))
    return false;
 
  // %rip is set to the address of the called function.
 
  LLDB_LOGF(log, "Writing IP: 0x%" PRIx64, (uint64_t)func_addr);
 
  if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_info, func_addr))
    return false;
 
  return true;
}
 
static bool ReadIntegerArgument(Scalar &scalar, unsigned int bit_width,
                                bool is_signed, Thread &thread,
                                uint32_t *argument_register_ids,
                                unsigned int &current_argument_register,
                                addr_t &current_stack_argument) {
  if (bit_width > 64)
    return false; // Scalar can't hold large integer arguments
 
  if (current_argument_register < 4) { // Windows pass first 4 arguments to register
    scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
        argument_register_ids[current_argument_register], 0);
    current_argument_register++;
    if (is_signed)
      scalar.SignExtend(bit_width);
    return true;
  }
  uint32_t byte_size = (bit_width + (CHAR_BIT - 1)) / CHAR_BIT;
  Status error;
  if (thread.GetProcess()->ReadScalarIntegerFromMemory(
          current_stack_argument, byte_size, is_signed, scalar, error)) {
    current_stack_argument += byte_size;
    return true;
  }
  return false;
}
 
bool ABIWindows_x86_64::GetArgumentValues(Thread &thread,
                                       ValueList &values) const {
  unsigned int num_values = values.GetSize();
  unsigned int value_index;
 
  // Extract the register context so we can read arguments from registers
 
  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 
  if (!reg_ctx)
    return false;
 
  // Get the pointer to the first stack argument so we have a place to start
  // when reading data
 
  addr_t sp = reg_ctx->GetSP(0);
 
  if (!sp)
    return false;
 
  addr_t current_stack_argument = sp + 8; // jump over return address
 
  uint32_t argument_register_ids[4];
 
  argument_register_ids[0] =
      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1)
          ->kinds[eRegisterKindLLDB];
  argument_register_ids[1] =
      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2)
          ->kinds[eRegisterKindLLDB];
  argument_register_ids[2] =
      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG3)
          ->kinds[eRegisterKindLLDB];
  argument_register_ids[3] =
      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG4)
          ->kinds[eRegisterKindLLDB];
 
  unsigned int current_argument_register = 0;
 
  for (value_index = 0; value_index < num_values; ++value_index) {
    Value *value = values.GetValueAtIndex(value_index);
 
    if (!value)
      return false;
 
    CompilerType compiler_type = value->GetCompilerType();
    std::optional<uint64_t> bit_size =
        llvm::expectedToOptional(compiler_type.GetBitSize(&thread));
    if (!bit_size)
      return false;
    bool is_signed;
 
    if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
      ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
                          argument_register_ids, current_argument_register,
                          current_stack_argument);
    } else if (compiler_type.IsPointerType()) {
      ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
                          argument_register_ids, current_argument_register,
                          current_stack_argument);
    }
  }
 
  return true;
}
 
Status ABIWindows_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                                            lldb::ValueObjectSP &new_value_sp) {
  Status error;
  if (!new_value_sp) {
    error = Status::FromErrorString("Empty value object for return value.");
    return error;
  }
 
  CompilerType compiler_type = new_value_sp->GetCompilerType();
  if (!compiler_type) {
    error = Status::FromErrorString("Null clang type for return value.");
    return error;
  }
 
  Thread *thread = frame_sp->GetThread().get();
 
  bool is_signed;
 
  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
 
  bool set_it_simple = false;
  if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
      compiler_type.IsPointerType()) {
    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("rax", 0);
 
    DataExtractor data;
    Status data_error;
    size_t num_bytes = new_value_sp->GetData(data, data_error);
    if (data_error.Fail()) {
      error = Status::FromErrorStringWithFormat(
          "Couldn't convert return value to raw data: %s",
          data_error.AsCString());
      return error;
    }
    lldb::offset_t offset = 0;
    if (num_bytes <= 8) {
      uint64_t raw_value = data.GetMaxU64(&offset, num_bytes);
 
      if (reg_ctx->WriteRegisterFromUnsigned(reg_info, raw_value))
        set_it_simple = true;
    } else {
      error = Status::FromErrorString(
          "We don't support returning longer than 64 bit "
          "integer values at present.");
    }
  } else if (compiler_type.IsRealFloatingPointType()) {
    std::optional<uint64_t> bit_width =
        llvm::expectedToOptional(compiler_type.GetBitSize(frame_sp.get()));
    if (!bit_width) {
      error = Status::FromErrorString("can't get type size");
      return error;
    }
    if (*bit_width <= 64) {
      const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0);
      RegisterValue xmm0_value;
      DataExtractor data;
      Status data_error;
      size_t num_bytes = new_value_sp->GetData(data, data_error);
      if (data_error.Fail()) {
        error = Status::FromErrorStringWithFormat(
            "Couldn't convert return value to raw data: %s",
            data_error.AsCString());
        return error;
      }
 
      unsigned char buffer[16];
      ByteOrder byte_order = data.GetByteOrder();
 
      data.CopyByteOrderedData(0, num_bytes, buffer, 16, byte_order);
      xmm0_value.SetBytes(buffer, 16, byte_order);
      reg_ctx->WriteRegister(xmm0_info, xmm0_value);
      set_it_simple = true;
    } else {
      // Windows doesn't support 80 bit FP
      error = Status::FromErrorString(
          "Windows-x86_64 doesn't allow FP larger than 64 bits.");
    }
  }
 
  if (!set_it_simple) {
    // Okay we've got a structure or something that doesn't fit in a simple
    // register.
    // TODO(wanyi): On Windows, if the return type is a struct:
    // 1) smaller that 64 bits and return by value -> RAX
    // 2) bigger than 64 bits, the caller will allocate memory for that struct
    // and pass the struct pointer in RCX then return the pointer in RAX
    error = Status::FromErrorString(
        "We only support setting simple integer and float "
        "return types at present.");
  }
 
  return error;
}
 
ValueObjectSP ABIWindows_x86_64::GetReturnValueObjectSimple(
    Thread &thread, CompilerType &return_compiler_type) const {
  ValueObjectSP return_valobj_sp;
  Value value;
 
  if (!return_compiler_type)
    return return_valobj_sp;
 
  value.SetCompilerType(return_compiler_type);
 
  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
  if (!reg_ctx)
    return return_valobj_sp;
 
  const uint32_t type_flags = return_compiler_type.GetTypeInfo();
  if (type_flags & eTypeIsScalar) {
    value.SetValueType(Value::ValueType::Scalar);
 
    bool success = false;
    if (type_flags & eTypeIsInteger) {
      // Extract the register context so we can read arguments from registers
      std::optional<uint64_t> byte_size =
          llvm::expectedToOptional(return_compiler_type.GetByteSize(&thread));
      if (!byte_size)
        return return_valobj_sp;
      uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
          reg_ctx->GetRegisterInfoByName("rax", 0), 0);
      const bool is_signed = (type_flags & eTypeIsSigned) != 0;
      switch (*byte_size) {
      default:
        break;
 
      case sizeof(uint64_t):
        if (is_signed)
          value.GetScalar() = (int64_t)(raw_value);
        else
          value.GetScalar() = (uint64_t)(raw_value);
        success = true;
        break;
 
      case sizeof(uint32_t):
        if (is_signed)
          value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
        else
          value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
        success = true;
        break;
 
      case sizeof(uint16_t):
        if (is_signed)
          value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
        else
          value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
        success = true;
        break;
 
      case sizeof(uint8_t):
        if (is_signed)
          value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
        else
          value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
        success = true;
        break;
      }
    } else if (type_flags & eTypeIsFloat) {
      if (type_flags & eTypeIsComplex) {
        // Don't handle complex yet.
      } else {
        std::optional<uint64_t> byte_size =
            llvm::expectedToOptional(return_compiler_type.GetByteSize(&thread));
        if (byte_size && *byte_size <= sizeof(long double)) {
          const RegisterInfo *xmm0_info =
              reg_ctx->GetRegisterInfoByName("xmm0", 0);
          RegisterValue xmm0_value;
          if (reg_ctx->ReadRegister(xmm0_info, xmm0_value)) {
            DataExtractor data;
            if (xmm0_value.GetData(data)) {
              lldb::offset_t offset = 0;
              if (*byte_size == sizeof(float)) {
                value.GetScalar() = (float)data.GetFloat(&offset);
                success = true;
              } else if (*byte_size == sizeof(double)) {
                // double and long double are the same on windows
                value.GetScalar() = (double)data.GetDouble(&offset);
                success = true;
              }
            }
          }
        }
      }
    }
 
    if (success)
      return_valobj_sp = ValueObjectConstResult::Create(
          thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
  } else if ((type_flags & eTypeIsPointer) ||
             (type_flags & eTypeInstanceIsPointer)) {
    unsigned rax_id =
        reg_ctx->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
    value.GetScalar() =
        (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
                                                                      0);
    value.SetValueType(Value::ValueType::Scalar);
    return_valobj_sp = ValueObjectConstResult::Create(
        thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
  } else if (type_flags & eTypeIsVector) {
    std::optional<uint64_t> byte_size =
        llvm::expectedToOptional(return_compiler_type.GetByteSize(&thread));
    if (byte_size && *byte_size > 0) {
      const RegisterInfo *xmm_reg =
          reg_ctx->GetRegisterInfoByName("xmm0", 0);
      if (xmm_reg == nullptr)
        xmm_reg = reg_ctx->GetRegisterInfoByName("mm0", 0);
 
      if (xmm_reg) {
        if (*byte_size <= xmm_reg->byte_size) {
          ProcessSP process_sp(thread.GetProcess());
          if (process_sp) {
            std::unique_ptr<DataBufferHeap> heap_data_up(
                new DataBufferHeap(*byte_size, 0));
            const ByteOrder byte_order = process_sp->GetByteOrder();
            RegisterValue reg_value;
            if (reg_ctx->ReadRegister(xmm_reg, reg_value)) {
              Status error;
              if (reg_value.GetAsMemoryData(*xmm_reg, heap_data_up->GetBytes(),
                                            heap_data_up->GetByteSize(),
                                            byte_order, error)) {
                DataExtractor data(DataBufferSP(heap_data_up.release()),
                                   byte_order,
                                   process_sp->GetTarget()
                                       .GetArchitecture()
                                       .GetAddressByteSize());
                return_valobj_sp = ValueObjectConstResult::Create(
                    &thread, return_compiler_type, ConstString(""), data);
              }
            }
          }
        }
      }
    }
  }
 
  return return_valobj_sp;
}
 
// The compiler will flatten the nested aggregate type into single
// layer and push the value to stack
// This helper function will flatten an aggregate type
// and return true if it can be returned in register(s) by value
// return false if the aggregate is in memory
static bool FlattenAggregateType(
    Thread &thread, ExecutionContext &exe_ctx,
    CompilerType &return_compiler_type,
    uint32_t data_byte_offset,
    std::vector<uint32_t> &aggregate_field_offsets,
    std::vector<CompilerType> &aggregate_compiler_types) {
 
  const uint32_t num_children = return_compiler_type.GetNumFields();
  for (uint32_t idx = 0; idx < num_children; ++idx) {
    std::string name;
    bool is_signed;
 
    uint64_t field_bit_offset = 0;
    CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
        idx, name, &field_bit_offset, nullptr, nullptr);
    std::optional<uint64_t> field_bit_width =
        llvm::expectedToOptional(field_compiler_type.GetBitSize(&thread));
 
    // if we don't know the size of the field (e.g. invalid type), exit
    if (!field_bit_width || *field_bit_width == 0) {
      return false;
    }
    // If there are any unaligned fields, this is stored in memory.
    if (field_bit_offset % *field_bit_width != 0) {
      return false;
    }
 
    // add overall offset
    uint32_t field_byte_offset = field_bit_offset / 8 + data_byte_offset;
 
    const uint32_t field_type_flags = field_compiler_type.GetTypeInfo();
    if (field_compiler_type.IsIntegerOrEnumerationType(is_signed) ||
        field_compiler_type.IsPointerType() ||
        // FIXME: is this correct for complex floats or float vector types?
        field_type_flags & eTypeIsFloat) {
      aggregate_field_offsets.push_back(field_byte_offset);
      aggregate_compiler_types.push_back(field_compiler_type);
    } else if (field_type_flags & eTypeHasChildren) {
      if (!FlattenAggregateType(thread, exe_ctx, field_compiler_type,
                                field_byte_offset, aggregate_field_offsets,
                                aggregate_compiler_types)) {
        return false;
      }
    }
  }
  return true;
}
 
ValueObjectSP ABIWindows_x86_64::GetReturnValueObjectImpl(
    Thread &thread, CompilerType &return_compiler_type) const {
  ValueObjectSP return_valobj_sp;
 
  if (!return_compiler_type) {
    return return_valobj_sp;
  }
 
  // try extract value as if it's a simple type
  return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
  if (return_valobj_sp) {
    return return_valobj_sp;
  }
 
  RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
  if (!reg_ctx_sp) {
    return return_valobj_sp;
  }
 
  std::optional<uint64_t> bit_width =
      llvm::expectedToOptional(return_compiler_type.GetBitSize(&thread));
  if (!bit_width) {
    return return_valobj_sp;
  }
 
  // if it's not simple or aggregate type, then we don't know how to handle it
  if (!return_compiler_type.IsAggregateType()) {
    return return_valobj_sp;
  }
 
  ExecutionContext exe_ctx(thread.shared_from_this());
  Target *target = exe_ctx.GetTargetPtr();
  uint32_t max_register_value_bit_width = 64;
 
  // The scenario here is to have a struct/class which is POD
  // if the return struct/class size is larger than 64 bits,
  // the caller will allocate memory for it and pass the return addr in RCX
  // then return the address in RAX
 
  // if the struct is returned by value in register (RAX)
  // its size has to be: 1, 2, 4, 8, 16, 32, or 64 bits (aligned)
  // for floating point, the return value will be copied over to RAX
  bool is_memory = *bit_width > max_register_value_bit_width ||
                   *bit_width & (*bit_width - 1);
  std::vector<uint32_t> aggregate_field_offsets;
  std::vector<CompilerType> aggregate_compiler_types;
  if (!is_memory &&
      FlattenAggregateType(thread, exe_ctx, return_compiler_type,
                           0, aggregate_field_offsets,
                           aggregate_compiler_types)) {
    ByteOrder byte_order = target->GetArchitecture().GetByteOrder();
    WritableDataBufferSP data_sp(
        new DataBufferHeap(max_register_value_bit_width / 8, 0));
    DataExtractor return_ext(data_sp, byte_order,
        target->GetArchitecture().GetAddressByteSize());
 
    // The only register used to return struct/class by value
    const RegisterInfo *rax_info =
        reg_ctx_sp->GetRegisterInfoByName("rax", 0);
    RegisterValue rax_value;
    reg_ctx_sp->ReadRegister(rax_info, rax_value);
    DataExtractor rax_data;
    rax_value.GetData(rax_data);
 
    uint32_t used_bytes =
        0; // Tracks how much of the rax registers we've consumed so far
 
    // in case of the returned type is a subclass of non-abstract-base class
    // it will have a padding to skip the base content
    if (aggregate_field_offsets.size())
      used_bytes = aggregate_field_offsets[0];
 
    const uint32_t num_children = aggregate_compiler_types.size();
    for (uint32_t idx = 0; idx < num_children; idx++) {
      bool is_signed;
 
      CompilerType field_compiler_type = aggregate_compiler_types[idx];
      uint32_t field_byte_width =
          (uint32_t)(llvm::expectedToOptional(
                         field_compiler_type.GetByteSize(&thread))
                         .value_or(0));
      uint32_t field_byte_offset = aggregate_field_offsets[idx];
 
      // this is unlikely w/o the overall size being greater than 8 bytes
      // For now, return a nullptr return value object.
      if (used_bytes >= 8 || used_bytes + field_byte_width > 8) {
        return return_valobj_sp;
      }
 
      DataExtractor *copy_from_extractor = nullptr;
      uint32_t copy_from_offset = 0;
      if (field_compiler_type.IsIntegerOrEnumerationType(is_signed) ||
          field_compiler_type.IsPointerType() ||
          // FIXME: is this correct for complex floats or float vector types?
          field_compiler_type.GetTypeInfo() & eTypeIsFloat) {
        copy_from_extractor = &rax_data;
        copy_from_offset = used_bytes;
        used_bytes += field_byte_width;
      }
      // These two tests are just sanity checks.  If I somehow get the type
      // calculation wrong above it is better to just return nothing than to
      // assert or crash.
      if (!copy_from_extractor) {
        return return_valobj_sp;
      }
      if (copy_from_offset + field_byte_width >
          copy_from_extractor->GetByteSize()) {
        return return_valobj_sp;
      }
      copy_from_extractor->CopyByteOrderedData(copy_from_offset,
          field_byte_width, data_sp->GetBytes() + field_byte_offset,
          field_byte_width, byte_order);
    }
    if (!is_memory) {
      // The result is in our data buffer.  Let's make a variable object out
      // of it:
      return_valobj_sp = ValueObjectConstResult::Create(
          &thread, return_compiler_type, ConstString(""), return_ext);
    }
  }
 
  // The Windows x86_64 ABI specifies that the return address for MEMORY
  // objects be placed in rax on exit from the function.
 
  // FIXME: This is just taking a guess, rax may very well no longer hold the
  // return storage location.
  // If we are going to do this right, when we make a new frame we should
  // check to see if it uses a memory return, and if we are at the first
  // instruction and if so stash away the return location.  Then we would
  // only return the memory return value if we know it is valid.
  if (is_memory) {
    unsigned rax_id =
        reg_ctx_sp->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
    lldb::addr_t storage_addr =
        (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
                                                                      0);
    return_valobj_sp = ValueObjectMemory::Create(
        &thread, "", Address(storage_addr, nullptr), return_compiler_type);
  }
  return return_valobj_sp;
}
 
// This defines the CFA as rsp+8
// the saved pc is at CFA-8 (i.e. rsp+0)
// The saved rsp is CFA+0
 
UnwindPlanSP ABIWindows_x86_64::CreateFunctionEntryUnwindPlan() {
  uint32_t sp_reg_num = dwarf_rsp;
  uint32_t pc_reg_num = dwarf_rip;
 
  UnwindPlan::Row row;
  row.GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 8);
  row.SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -8, false);
  row.SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
  auto plan_sp = std::make_shared<UnwindPlan>(eRegisterKindDWARF);
  plan_sp->AppendRow(std::move(row));
  plan_sp->SetSourceName("x86_64 at-func-entry default");
  plan_sp->SetSourcedFromCompiler(eLazyBoolNo);
  return plan_sp;
}
 
// Windows-x86_64 doesn't use %rbp
// No available Unwind information for Windows-x86_64 (section .pdata)
// Let's use SysV-x86_64 one for now
UnwindPlanSP ABIWindows_x86_64::CreateDefaultUnwindPlan() {
  uint32_t fp_reg_num = dwarf_rbp;
  uint32_t sp_reg_num = dwarf_rsp;
  uint32_t pc_reg_num = dwarf_rip;
 
  UnwindPlan::Row row;
 
  const int32_t ptr_size = 8;
  row.GetCFAValue().SetIsRegisterPlusOffset(dwarf_rbp, 2 * ptr_size);
  row.SetOffset(0);
  row.SetUnspecifiedRegistersAreUndefined(true);
 
  row.SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
  row.SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
  row.SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
  auto plan_sp = std::make_shared<UnwindPlan>(eRegisterKindDWARF);
  plan_sp->AppendRow(std::move(row));
  plan_sp->SetSourceName("x86_64 default unwind plan");
  plan_sp->SetSourcedFromCompiler(eLazyBoolNo);
  plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
  return plan_sp;
}
 
bool ABIWindows_x86_64::RegisterIsVolatile(const RegisterInfo *reg_info) {
  return !RegisterIsCalleeSaved(reg_info);
}
 
bool ABIWindows_x86_64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
  if (!reg_info)
    return false;
  assert(reg_info->name != nullptr && "unnamed register?");
  std::string Name = std::string(reg_info->name);
  bool IsCalleeSaved =
      llvm::StringSwitch<bool>(Name)
          .Cases({"rbx", "ebx", "rbp", "ebp", "rdi", "edi", "rsi", "esi"}, true)
          .Cases({"rsp", "esp", "r12", "r13", "r14", "r15", "sp", "fp"}, true)
          .Cases({"xmm6", "xmm7", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12",
                  "xmm13", "xmm14", "xmm15"},
                 true)
          .Default(false);
  return IsCalleeSaved;
}
 
uint32_t ABIWindows_x86_64::GetGenericNum(llvm::StringRef reg) {
  return llvm::StringSwitch<uint32_t>(reg)
      .Case("rip", LLDB_REGNUM_GENERIC_PC)
      .Case("rsp", LLDB_REGNUM_GENERIC_SP)
      .Case("rbp", LLDB_REGNUM_GENERIC_FP)
      .Case("rflags", LLDB_REGNUM_GENERIC_FLAGS)
      // gdbserver uses eflags
      .Case("eflags", LLDB_REGNUM_GENERIC_FLAGS)
      .Case("rcx", LLDB_REGNUM_GENERIC_ARG1)
      .Case("rdx", LLDB_REGNUM_GENERIC_ARG2)
      .Case("r8", LLDB_REGNUM_GENERIC_ARG3)
      .Case("r9", LLDB_REGNUM_GENERIC_ARG4)
      .Default(LLDB_INVALID_REGNUM);
}
 
void ABIWindows_x86_64::Initialize() {
  PluginManager::RegisterPlugin(
      GetPluginNameStatic(), "Windows ABI for x86_64 targets", CreateInstance);
}
 
void ABIWindows_x86_64::Terminate() {
  PluginManager::UnregisterPlugin(CreateInstance);
}