Make the error condition in Value::ValueType explicit (NFC)

[aprantl]

Summary

The comment for ValueType claims that all values <1 are errors, but not all switch statements take this into account. This patch introduces an explicit Error case and deletes all default: cases, so we get warned about incomplete switch coverage.

[aprantl]

Phabricator got really confused by the diff context. Reposting without context.

[aprantl]

Found two more uncovered cases. Drive-by fix of two error messages.

[teemperor]

This LGTM module the unrelated changes in that one file. A third pair of eyes probably won't hurt, so I'll give the others a change to look over this before I accept, but otherwise I'll just accept tomorrow.

(Btw, if you intend to cherry-pick this into swift/main for some reason then please let me know as this probably will cause a bunch of conflicts with the temporarily reverted patch from Pavel).

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

38

The changes in this whole file seem like an accidental commit slipped in.

[aprantl]

Upload the correct patch this time!? Hopefully?

[shafik]

lldb/source/Core/Value.cpp

321

Would it make sense to also do an error.SetErrorString(...?

575–576

In the invalid case does m_value have some initial value i.e. it is not uninitialized.

629

I love the "???"

lldb/source/Core/ValueObject.cpp

339–343

No handing for ValueType::Invalid here?

858–861

No handling for ValueType::Invalid here?

Same for some code below as well.

lldb/source/Core/ValueObjectConstResult.cpp

148

dead code?

lldb/source/Core/ValueObjectVariable.cpp

200

Does m_error.SetErrorString make sense here?

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

1668

Dead code?

lldb/source/Target/ABI.cpp

122–123

No handling for ValueType::Invalid here?

[aprantl]

Address review feedback!

[shafik]

LGTM

[aprantl]

(Btw, if you intend to cherry-pick this into swift/main for some reason then please let me know as this probably will cause a bunch of conflicts with the temporarily reverted patch from Pavel).

I don't need to cherry-pick it, so I won't for now.

lldb/source/Core/Value.cpp

575–576

I don't understand what you are asking here?

lldb/source/Core/ValueObjectConstResult.cpp

148

Yes, but I'm not going to touch this in this commit.

[shafik]

lldb/source/Core/Value.cpp

575–576

The other cases initialize m_value or call Clear on it and m_value is return at the end and I was asking is it is properly initialized.

[aprantl]

This landed as 057efa9916cdc354ef4653bcd128a578cc43125e I messed up the commit message.

lldb/include/lldb/Core/Value.h

 class Type;
 class Variable;
 }
 
 namespace lldb_private {
 
 class Value {
 public:
-  // Values Less than zero are an error, greater than or equal to zero returns
-  // what the Scalar result is.
-  enum ValueType {
-    // m_value contains...
-    // ============================
-    eValueTypeScalar,      // raw scalar value
-    eValueTypeFileAddress, // file address value
-    eValueTypeLoadAddress, // load address value
-    eValueTypeHostAddress  // host address value (for memory in the process that
-                           // is using liblldb)
+  /// Type that describes Value::m_value.
+  enum class ValueType {
+    Invalid = -1,
+    // m_value contains:
+    /// A raw scalar value.
+    Scalar = 0,
+    /// A file address value.
+    FileAddress,
+    /// A load address value.
+    LoadAddress,
+    /// A host address value (for memory in the process that < A is
+    /// using liblldb).
+    HostAddress
   };
 
-  enum ContextType // Type that describes Value::m_context
-  {
-    // m_context contains...
-    // ====================
-    eContextTypeInvalid,      // undefined
-    eContextTypeRegisterInfo, // RegisterInfo * (can be a scalar or a vector
-                              // register)
-    eContextTypeLLDBType,     // lldb_private::Type *
-    eContextTypeVariable      // lldb_private::Variable *
+  /// Type that describes Value::m_context.
+  enum class ContextType {
+    // m_context contains:
+    /// Undefined.
+    Invalid = -1,
+    /// RegisterInfo * (can be a scalar or a vector register).
+    RegisterInfo = 0,
+    /// lldb_private::Type *.
+    LLDBType,
+    /// lldb_private::Variable *.
+    Variable
   };
 
   Value();
   Value(const Scalar &scalar);
   Value(const void *bytes, int len);
   Value(const Value &rhs);
 
   void SetBytes(const void *bytes, int len);
public:
   AddressType GetValueAddressType() const;
 
   ContextType GetContextType() const { return m_context_type; }
 
   void SetValueType(ValueType value_type) { m_value_type = value_type; }
 
   void ClearContext() {
     m_context = nullptr;
-    m_context_type = eContextTypeInvalid;
+    m_context_type = ContextType::Invalid;
   }
 
   void SetContext(ContextType context_type, void *p) {
     m_context_type = context_type;
     m_context = p;
-    if (m_context_type == eContextTypeRegisterInfo) {
+    if (m_context_type == ContextType::RegisterInfo) {
       RegisterInfo *reg_info = GetRegisterInfo();
       if (reg_info->encoding == lldb::eEncodingVector)
-        SetValueType(eValueTypeScalar);
+        SetValueType(ValueType::Scalar);
     }
   }
 
   RegisterInfo *GetRegisterInfo() const;
 
   Type *GetType();
 
   Scalar &ResolveValue(ExecutionContext *exe_ctx);

lldb/include/lldb/Expression/ExpressionVariable.h

public:
   void ValueUpdated() { m_frozen_sp->ValueUpdated(); }
 
   RegisterInfo *GetRegisterInfo() {
     return m_frozen_sp->GetValue().GetRegisterInfo();
   }
 
   void SetRegisterInfo(const RegisterInfo *reg_info) {
     return m_frozen_sp->GetValue().SetContext(
-        Value::eContextTypeRegisterInfo, const_cast<RegisterInfo *>(reg_info));
+        Value::ContextType::RegisterInfo, const_cast<RegisterInfo *>(reg_info));
   }
 
   CompilerType GetCompilerType() { return m_frozen_sp->GetCompilerType(); }
 
   void SetCompilerType(const CompilerType &compiler_type) {
     m_frozen_sp->GetValue().SetCompilerType(compiler_type);
   }
 

lldb/source/Core/Value.cpp

 
 #include <inttypes.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 Value::Value()
     : m_value(), m_compiler_type(), m_context(nullptr),
-      m_value_type(eValueTypeScalar), m_context_type(eContextTypeInvalid),
+      m_value_type(ValueType::Scalar), m_context_type(ContextType::Invalid),
       m_data_buffer() {}
 
 Value::Value(const Scalar &scalar)
     : m_value(scalar), m_compiler_type(), m_context(nullptr),
-      m_value_type(eValueTypeScalar), m_context_type(eContextTypeInvalid),
+      m_value_type(ValueType::Scalar), m_context_type(ContextType::Invalid),
       m_data_buffer() {}
 
 Value::Value(const void *bytes, int len)
     : m_value(), m_compiler_type(), m_context(nullptr),
-      m_value_type(eValueTypeHostAddress), m_context_type(eContextTypeInvalid),
+      m_value_type(ValueType::HostAddress), m_context_type(ContextType::Invalid),
       m_data_buffer() {
   SetBytes(bytes, len);
 }
 
 Value::Value(const Value &v)
     : m_value(v.m_value), m_compiler_type(v.m_compiler_type),
       m_context(v.m_context), m_value_type(v.m_value_type),
       m_context_type(v.m_context_type), m_data_buffer() {
if ((rhs_value != 0) &&
 
       m_value = (uintptr_t)m_data_buffer.GetBytes();
     }
   }
   return *this;
 }
 
 void Value::SetBytes(const void *bytes, int len) {
-  m_value_type = eValueTypeHostAddress;
+  m_value_type = ValueType::HostAddress;
   m_data_buffer.CopyData(bytes, len);
   m_value = (uintptr_t)m_data_buffer.GetBytes();
 }
 
 void Value::AppendBytes(const void *bytes, int len) {
-  m_value_type = eValueTypeHostAddress;
+  m_value_type = ValueType::HostAddress;
   m_data_buffer.AppendData(bytes, len);
   m_value = (uintptr_t)m_data_buffer.GetBytes();
 }
 
 void Value::Dump(Stream *strm) {
   m_value.GetValue(strm, true);
   strm->Printf(", value_type = %s, context = %p, context_type = %s",
                Value::GetValueTypeAsCString(m_value_type), m_context,
                Value::GetContextTypeAsCString(m_context_type));
 }
 
 Value::ValueType Value::GetValueType() const { return m_value_type; }
 
 AddressType Value::GetValueAddressType() const {
   switch (m_value_type) {
-  case eValueTypeScalar:
+  case ValueType::Invalid:
+  case ValueType::Scalar:
     break;
-  case eValueTypeLoadAddress:
+  case ValueType::LoadAddress:
     return eAddressTypeLoad;
-  case eValueTypeFileAddress:
+  case ValueType::FileAddress:
     return eAddressTypeFile;
-  case eValueTypeHostAddress:
+  case ValueType::HostAddress:
     return eAddressTypeHost;
   }
   return eAddressTypeInvalid;
 }
 
 RegisterInfo *Value::GetRegisterInfo() const {
-  if (m_context_type == eContextTypeRegisterInfo)
+  if (m_context_type == ContextType::RegisterInfo)
     return static_cast<RegisterInfo *>(m_context);
   return nullptr;
 }
 
 Type *Value::GetType() {
-  if (m_context_type == eContextTypeLLDBType)
+  if (m_context_type == ContextType::LLDBType)
     return static_cast<Type *>(m_context);
   return nullptr;
 }
 
 size_t Value::AppendDataToHostBuffer(const Value &rhs) {
   if (this == &rhs)
     return 0;
 
   size_t curr_size = m_data_buffer.GetByteSize();
   Status error;
   switch (rhs.GetValueType()) {
-  case eValueTypeScalar: {
+  case ValueType::Invalid:
+    return 0;
+  case ValueType::Scalar: {
     const size_t scalar_size = rhs.m_value.GetByteSize();
     if (scalar_size > 0) {
       const size_t new_size = curr_size + scalar_size;
       if (ResizeData(new_size) == new_size) {
         rhs.m_value.GetAsMemoryData(m_data_buffer.GetBytes() + curr_size,
                                     scalar_size, endian::InlHostByteOrder(),
                                     error);
         return scalar_size;
       }
     }
   } break;
-  case eValueTypeFileAddress:
-  case eValueTypeLoadAddress:
-  case eValueTypeHostAddress: {
+  case ValueType::FileAddress:
+  case ValueType::LoadAddress:
+  case ValueType::HostAddress: {
     const uint8_t *src = rhs.GetBuffer().GetBytes();
     const size_t src_len = rhs.GetBuffer().GetByteSize();
     if (src && src_len > 0) {
       const size_t new_size = curr_size + src_len;
       if (ResizeData(new_size) == new_size) {
         ::memcpy(m_data_buffer.GetBytes() + curr_size, src, src_len);
         return src_len;
       }
     }
   } break;
   }
   return 0;
 }
 
 size_t Value::ResizeData(size_t len) {
-  m_value_type = eValueTypeHostAddress;
+  m_value_type = ValueType::HostAddress;
   m_data_buffer.SetByteSize(len);
   m_value = (uintptr_t)m_data_buffer.GetBytes();
   return m_data_buffer.GetByteSize();
 }
 
 bool Value::ValueOf(ExecutionContext *exe_ctx) {
   switch (m_context_type) {
-  case eContextTypeInvalid:
-  case eContextTypeRegisterInfo: // RegisterInfo *
-  case eContextTypeLLDBType:     // Type *
+  case ContextType::Invalid:
+  case ContextType::RegisterInfo: // RegisterInfo *
+  case ContextType::LLDBType:     // Type *
     break;
 
-  case eContextTypeVariable: // Variable *
+  case ContextType::Variable: // Variable *
     ResolveValue(exe_ctx);
     return true;
   }
   return false;
 }
 
 uint64_t Value::GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx) {
   switch (m_context_type) {
-  case eContextTypeRegisterInfo: // RegisterInfo *
+  case ContextType::RegisterInfo: // RegisterInfo *
     if (GetRegisterInfo()) {
       if (error_ptr)
         error_ptr->Clear();
       return GetRegisterInfo()->byte_size;
     }
     break;
 
-  case eContextTypeInvalid:
-  case eContextTypeLLDBType: // Type *
-  case eContextTypeVariable: // Variable *
+  case ContextType::Invalid:
+  case ContextType::LLDBType: // Type *
+  case ContextType::Variable: // Variable *
   {
     auto *scope = exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
     if (llvm::Optional<uint64_t> size = GetCompilerType().GetByteSize(scope)) {
       if (error_ptr)
         error_ptr->Clear();
       return *size;
     }
     break;
   }
   }
   if (error_ptr && error_ptr->Success())
     error_ptr->SetErrorString("Unable to determine byte size.");
   return 0;
 }
 
 const CompilerType &Value::GetCompilerType() {
   if (!m_compiler_type.IsValid()) {
     switch (m_context_type) {
-    case eContextTypeInvalid:
+    case ContextType::Invalid:
       break;
 
-    case eContextTypeRegisterInfo:
+    case ContextType::RegisterInfo:
       break; // TODO: Eventually convert into a compiler type?
 
-    case eContextTypeLLDBType: {
+    case ContextType::LLDBType: {
       Type *lldb_type = GetType();
       if (lldb_type)
         m_compiler_type = lldb_type->GetForwardCompilerType();
     } break;
 
-    case eContextTypeVariable: {
+    case ContextType::Variable: {
       Variable *variable = GetVariable();
       if (variable) {
         Type *variable_type = variable->GetType();
         if (variable_type)
           m_compiler_type = variable_type->GetForwardCompilerType();
       }
     } break;
     }
   }
 
   return m_compiler_type;
 }
 
 void Value::SetCompilerType(const CompilerType &compiler_type) {
   m_compiler_type = compiler_type;
 }
 
 lldb::Format Value::GetValueDefaultFormat() {
   switch (m_context_type) {
-  case eContextTypeRegisterInfo:
+  case ContextType::RegisterInfo:
     if (GetRegisterInfo())
       return GetRegisterInfo()->format;
     break;
 
-  case eContextTypeInvalid:
-  case eContextTypeLLDBType:
-  case eContextTypeVariable: {
+  case ContextType::Invalid:
+  case ContextType::LLDBType:
+  case ContextType::Variable: {
     const CompilerType &ast_type = GetCompilerType();
     if (ast_type.IsValid())
       return ast_type.GetFormat();
   } break;
   }
 
   // Return a good default in case we can't figure anything out
   return eFormatHex;
 }
 
 bool Value::GetData(DataExtractor &data) {
   switch (m_value_type) {
-  case eValueTypeScalar:
+  case ValueType::Invalid:
+    return false;
+  case ValueType::Scalar:
     if (m_value.GetData(data))
       return true;
     break;
 
-  case eValueTypeLoadAddress:
-  case eValueTypeFileAddress:
-  case eValueTypeHostAddress:
+  case ValueType::LoadAddress:
+  case ValueType::FileAddress:
+  case ValueType::HostAddress:
     if (m_data_buffer.GetByteSize()) {
       data.SetData(m_data_buffer.GetBytes(), m_data_buffer.GetByteSize(),
                    data.GetByteOrder());
       return true;
     }
     break;
   }
 
Status Value::GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
   const CompilerType &ast_type = GetCompilerType();
   llvm::Optional<uint64_t> type_size = ast_type.GetByteSize(
       exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
   // Nothing to be done for a zero-sized type.
   if (type_size && *type_size == 0)
     return error;
 
   switch (m_value_type) {
-  case eValueTypeScalar: {
+  case ValueType::Invalid:
+    error.SetErrorString("invalid value");
+    break;
+  case ValueType::Scalar: {
     data.SetByteOrder(endian::InlHostByteOrder());
     if (ast_type.IsValid())
       data.SetAddressByteSize(ast_type.GetPointerByteSize());
     else
       data.SetAddressByteSize(sizeof(void *));
 
     uint32_t limit_byte_size = UINT32_MAX;
 
     if (type_size)
       limit_byte_size = *type_size;
 
     if (limit_byte_size <= m_value.GetByteSize()) {
       if (m_value.GetData(data, limit_byte_size))
         return error; // Success;
     }
 
     error.SetErrorString("extracting data from value failed");
     break;
   }
-  case eValueTypeLoadAddress:
+  case ValueType::LoadAddress:
     if (exe_ctx == nullptr) {
       error.SetErrorString("can't read load address (no execution context)");
     } else {
       Process *process = exe_ctx->GetProcessPtr();
       if (process == nullptr || !process->IsAlive()) {
         Target *target = exe_ctx->GetTargetPtr();
         if (target) {
           // Allow expressions to run and evaluate things when the target has
if (exe_ctx == nullptr) {
         data.SetByteOrder(
             process->GetTarget().GetArchitecture().GetByteOrder());
         data.SetAddressByteSize(
             process->GetTarget().GetArchitecture().GetAddressByteSize());
       }
     }
     break;
 
-  case eValueTypeFileAddress:
+  case ValueType::FileAddress:
     if (exe_ctx == nullptr) {
       error.SetErrorString("can't read file address (no execution context)");
     } else if (exe_ctx->GetTargetPtr() == nullptr) {
       error.SetErrorString("can't read file address (invalid target)");
     } else {
       address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
       if (address == LLDB_INVALID_ADDRESS) {
         error.SetErrorString("invalid file address");
if (exe_ctx == nullptr) {
           // context (which Module it came from)
           error.SetErrorString(
               "can't read memory from file address without more context");
         }
       }
     }
     break;
 
-  case eValueTypeHostAddress:
+  case ValueType::HostAddress:
     address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
     address_type = eAddressTypeHost;
     if (exe_ctx) {
       Target *target = exe_ctx->GetTargetPtr();
       if (target) {
         data.SetByteOrder(target->GetArchitecture().GetByteOrder());
         data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
         break;
Status Value::GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
 
   return error;
 }
 
 Scalar &Value::ResolveValue(ExecutionContext *exe_ctx) {
   const CompilerType &compiler_type = GetCompilerType();
   if (compiler_type.IsValid()) {
     switch (m_value_type) {
-    case eValueTypeScalar: // raw scalar value
+    case ValueType::Invalid:
+    case ValueType::Scalar: // raw scalar value
       break;
 
-    case eValueTypeFileAddress:
-    case eValueTypeLoadAddress: // load address value
-    case eValueTypeHostAddress: // host address value (for memory in the process
+    case ValueType::FileAddress:
+    case ValueType::LoadAddress: // load address value
+    case ValueType::HostAddress: // host address value (for memory in the process
                                 // that is using liblldb)
     {
       DataExtractor data;
       lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS);
       Status error(GetValueAsData(exe_ctx, data, nullptr));
       if (error.Success()) {
         Scalar scalar;
         if (compiler_type.GetValueAsScalar(
                 data, 0, data.GetByteSize(), scalar,
                 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr)) {
           m_value = scalar;
-          m_value_type = eValueTypeScalar;
+          m_value_type = ValueType::Scalar;
         } else {
           if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) {
             m_value.Clear();
-            m_value_type = eValueTypeScalar;
+            m_value_type = ValueType::Scalar;
           }
         }
       } else {
         if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) {
           m_value.Clear();
-          m_value_type = eValueTypeScalar;
+          m_value_type = ValueType::Scalar;
         }
       }
     } break;
     }
   }
   return m_value;
 }
 
 Variable *Value::GetVariable() {
-  if (m_context_type == eContextTypeVariable)
+  if (m_context_type == ContextType::Variable)
     return static_cast<Variable *>(m_context);
   return nullptr;
 }
 
 void Value::Clear() {
   m_value.Clear();
   m_compiler_type.Clear();
-  m_value_type = eValueTypeScalar;
+  m_value_type = ValueType::Scalar;
   m_context = nullptr;
-  m_context_type = eContextTypeInvalid;
+  m_context_type = ContextType::Invalid;
   m_data_buffer.Clear();
 }
 
 const char *Value::GetValueTypeAsCString(ValueType value_type) {
   switch (value_type) {
-  case eValueTypeScalar:
+  case ValueType::Invalid:
+    return "invalid";
+  case ValueType::Scalar:
     return "scalar";
-  case eValueTypeFileAddress:
+  case ValueType::FileAddress:
     return "file address";
-  case eValueTypeLoadAddress:
+  case ValueType::LoadAddress:
     return "load address";
-  case eValueTypeHostAddress:
+  case ValueType::HostAddress:
     return "host address";
   };
-  return "???";
+  llvm_unreachable("enum cases exhausted.");
 }
 
 const char *Value::GetContextTypeAsCString(ContextType context_type) {
   switch (context_type) {
-  case eContextTypeInvalid:
+  case ContextType::Invalid:
     return "invalid";
-  case eContextTypeRegisterInfo:
+  case ContextType::RegisterInfo:
     return "RegisterInfo *";
-  case eContextTypeLLDBType:
+  case ContextType::LLDBType:
     return "Type *";
-  case eContextTypeVariable:
+  case ContextType::Variable:
     return "Variable *";
   };
-  return "???";
+  llvm_unreachable("enum cases exhausted.");
 }
 
 void Value::ConvertToLoadAddress(Module *module, Target *target) {
-  if (!module || !target || (GetValueType() != eValueTypeFileAddress))
+  if (!module || !target || (GetValueType() != ValueType::FileAddress))
     return;
 
   lldb::addr_t file_addr = GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
   if (file_addr == LLDB_INVALID_ADDRESS)
     return;
 
   Address so_addr;
   if (!module->ResolveFileAddress(file_addr, so_addr))
     return;
   lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
   if (load_addr == LLDB_INVALID_ADDRESS)
     return;
 
-  SetValueType(Value::eValueTypeLoadAddress);
+  SetValueType(Value::ValueType::LoadAddress);
   GetScalar() = load_addr;
 }
 
 ValueList::ValueList(const ValueList &rhs) { m_values = rhs.m_values; }
 
 const ValueList &ValueList::operator=(const ValueList &rhs) {
   m_values = rhs.m_values;
   return *this;

lldb/source/Core/ValueObject.cpp

const char *ValueObject::GetLocationAsCStringImpl(const Value &value,
                                                   const DataExtractor &data) {
   if (UpdateValueIfNeeded(false)) {
     if (m_location_str.empty()) {
       StreamString sstr;
 
       Value::ValueType value_type = value.GetValueType();
 
       switch (value_type) {
-      case Value::eValueTypeScalar:
-        if (value.GetContextType() == Value::eContextTypeRegisterInfo) {
+      case Value::ValueType::Invalid:
+        m_location_str = "invalid";
+        break;
+      case Value::ValueType::Scalar:
+        if (value.GetContextType() == Value::ContextType::RegisterInfo) {
           RegisterInfo *reg_info = value.GetRegisterInfo();
           if (reg_info) {
             if (reg_info->name)
               m_location_str = reg_info->name;
             else if (reg_info->alt_name)
               m_location_str = reg_info->alt_name;
             if (m_location_str.empty())
               m_location_str = (reg_info->encoding == lldb::eEncodingVector)
                                    ? "vector"
                                    : "scalar";
           }
         }
         if (m_location_str.empty())
           m_location_str = "scalar";
         break;
 
-      case Value::eValueTypeLoadAddress:
-      case Value::eValueTypeFileAddress:
-      case Value::eValueTypeHostAddress: {
+      case Value::ValueType::LoadAddress:
+      case Value::ValueType::FileAddress:
+      case Value::ValueType::HostAddress: {
         uint32_t addr_nibble_size = data.GetAddressByteSize() * 2;
         sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size,
                     value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS));
         m_location_str = std::string(sstr.GetString());
       } break;
       }
     }
   }
bool ValueObject::SetData(DataExtractor &data, Status &error) {
   uint64_t count = 0;
   const Encoding encoding = GetCompilerType().GetEncoding(count);
 
   const size_t byte_size = GetByteSize().getValueOr(0);
 
   Value::ValueType value_type = m_value.GetValueType();
 
   switch (value_type) {
-  case Value::eValueTypeScalar: {
+  case Value::ValueType::Invalid:
+    error.SetErrorString("invalid location");
+    return false;
+  case Value::ValueType::Scalar: {
     Status set_error =
         m_value.GetScalar().SetValueFromData(data, encoding, byte_size);
 
     if (!set_error.Success()) {
       error.SetErrorStringWithFormat("unable to set scalar value: %s",
                                      set_error.AsCString());
       return false;
     }
   } break;
-  case Value::eValueTypeLoadAddress: {
+  case Value::ValueType::LoadAddress: {
     // If it is a load address, then the scalar value is the storage location
     // of the data, and we have to shove this value down to that load location.
     ExecutionContext exe_ctx(GetExecutionContextRef());
     Process *process = exe_ctx.GetProcessPtr();
     if (process) {
       addr_t target_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
       size_t bytes_written = process->WriteMemory(
           target_addr, data.GetDataStart(), byte_size, error);
       if (!error.Success())
         return false;
       if (bytes_written != byte_size) {
         error.SetErrorString("unable to write value to memory");
         return false;
       }
     }
   } break;
-  case Value::eValueTypeHostAddress: {
+  case Value::ValueType::HostAddress: {
     // If it is a host address, then we stuff the scalar as a DataBuffer into
     // the Value's data.
     DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0));
     m_data.SetData(buffer_sp, 0);
     data.CopyByteOrderedData(0, byte_size,
                              const_cast<uint8_t *>(m_data.GetDataStart()),
                              byte_size, m_data.GetByteOrder());
     m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
   } break;
-  case Value::eValueTypeFileAddress:
+  case Value::ValueType::FileAddress:
     break;
   }
 
   // If we have reached this point, then we have successfully changed the
   // value.
   SetNeedsUpdate();
   return true;
 }
if (UpdateValueIfNeeded(true)) {
     lldb::Format my_format = GetFormat();
     if (my_format == lldb::eFormatDefault) {
       if (m_type_format_sp)
         format_sp = m_type_format_sp;
       else {
         if (m_is_bitfield_for_scalar)
           my_format = eFormatUnsigned;
         else {
-          if (m_value.GetContextType() == Value::eContextTypeRegisterInfo) {
+          if (m_value.GetContextType() == Value::ContextType::RegisterInfo) {
             const RegisterInfo *reg_info = m_value.GetRegisterInfo();
             if (reg_info)
               my_format = reg_info->format;
           } else {
             my_format = GetValue().GetCompilerType().GetFormat();
           }
         }
       }
addr_t ValueObject::GetAddressOf(bool scalar_is_load_address,
   // Can't take address of a bitfield
   if (IsBitfield())
     return LLDB_INVALID_ADDRESS;
 
   if (!UpdateValueIfNeeded(false))
     return LLDB_INVALID_ADDRESS;
 
   switch (m_value.GetValueType()) {
-  case Value::eValueTypeScalar:
+  case Value::ValueType::Invalid:
+    return LLDB_INVALID_ADDRESS;
+  case Value::ValueType::Scalar:
     if (scalar_is_load_address) {
       if (address_type)
         *address_type = eAddressTypeLoad;
       return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
     }
     break;
 
-  case Value::eValueTypeLoadAddress:
-  case Value::eValueTypeFileAddress: {
+  case Value::ValueType::LoadAddress:
+  case Value::ValueType::FileAddress: {
     if (address_type)
       *address_type = m_value.GetValueAddressType();
     return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
   } break;
-  case Value::eValueTypeHostAddress: {
+  case Value::ValueType::HostAddress: {
     if (address_type)
       *address_type = m_value.GetValueAddressType();
     return LLDB_INVALID_ADDRESS;
   } break;
   }
   if (address_type)
     *address_type = eAddressTypeInvalid;
   return LLDB_INVALID_ADDRESS;
 }
 
 addr_t ValueObject::GetPointerValue(AddressType *address_type) {
   addr_t address = LLDB_INVALID_ADDRESS;
   if (address_type)
     *address_type = eAddressTypeInvalid;
 
   if (!UpdateValueIfNeeded(false))
     return address;
 
   switch (m_value.GetValueType()) {
-  case Value::eValueTypeScalar:
+  case Value::ValueType::Invalid:
+    return LLDB_INVALID_ADDRESS;
+  case Value::ValueType::Scalar:
     address = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
     break;
 
-  case Value::eValueTypeHostAddress:
-  case Value::eValueTypeLoadAddress:
-  case Value::eValueTypeFileAddress: {
+  case Value::ValueType::HostAddress:
+  case Value::ValueType::LoadAddress:
+  case Value::ValueType::FileAddress: {
     lldb::offset_t data_offset = 0;
     address = m_data.GetAddress(&data_offset);
   } break;
   }
 
   if (address_type)
     *address_type = GetAddressTypeOfChildren();
 
bool ValueObject::SetValueFromCString(const char *value_str, Status &error) {
 
   uint64_t count = 0;
   const Encoding encoding = GetCompilerType().GetEncoding(count);
 
   const size_t byte_size = GetByteSize().getValueOr(0);
 
   Value::ValueType value_type = m_value.GetValueType();
 
-  if (value_type == Value::eValueTypeScalar) {
+  if (value_type == Value::ValueType::Scalar) {
     // If the value is already a scalar, then let the scalar change itself:
     m_value.GetScalar().SetValueFromCString(value_str, encoding, byte_size);
   } else if (byte_size <= 16) {
     // If the value fits in a scalar, then make a new scalar and again let the
     // scalar code do the conversion, then figure out where to put the new
     // value.
     Scalar new_scalar;
     error = new_scalar.SetValueFromCString(value_str, encoding, byte_size);
     if (error.Success()) {
       switch (value_type) {
-      case Value::eValueTypeLoadAddress: {
+      case Value::ValueType::LoadAddress: {
         // If it is a load address, then the scalar value is the storage
         // location of the data, and we have to shove this value down to that
         // load location.
         ExecutionContext exe_ctx(GetExecutionContextRef());
         Process *process = exe_ctx.GetProcessPtr();
         if (process) {
           addr_t target_addr =
               m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
           size_t bytes_written = process->WriteScalarToMemory(
               target_addr, new_scalar, byte_size, error);
           if (!error.Success())
             return false;
           if (bytes_written != byte_size) {
             error.SetErrorString("unable to write value to memory");
             return false;
           }
         }
       } break;
-      case Value::eValueTypeHostAddress: {
+      case Value::ValueType::HostAddress: {
         // If it is a host address, then we stuff the scalar as a DataBuffer
         // into the Value's data.
         DataExtractor new_data;
         new_data.SetByteOrder(m_data.GetByteOrder());
 
         DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0));
         m_data.SetData(buffer_sp, 0);
         bool success = new_scalar.GetData(new_data);
         if (success) {
           new_data.CopyByteOrderedData(
               0, byte_size, const_cast<uint8_t *>(m_data.GetDataStart()),
               byte_size, m_data.GetByteOrder());
         }
         m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
 
       } break;
-      case Value::eValueTypeFileAddress:
-      case Value::eValueTypeScalar:
+      case Value::ValueType::Invalid:
+        error.SetErrorString("invalid location");
+        return false;
+      case Value::ValueType::FileAddress:
+      case Value::ValueType::Scalar:
         break;
       }
     } else {
       return false;
     }
   } else {
     // We don't support setting things bigger than a scalar at present.
     error.SetErrorString("unable to write aggregate data type");
void ValueObject::GetExpressionPath(Stream &s,
                                     GetExpressionPathFormat epformat) {
   // synthetic children do not actually "exist" as part of the hierarchy, and
   // sometimes they are consed up in ways that don't make sense from an
   // underlying language/API standpoint. So, use a special code path here to
   // return something that can hopefully be used in expression
   if (m_is_synthetic_children_generated) {
     UpdateValueIfNeeded();
 
-    if (m_value.GetValueType() == Value::eValueTypeLoadAddress) {
+    if (m_value.GetValueType() == Value::ValueType::LoadAddress) {
       if (IsPointerOrReferenceType()) {
         s.Printf("((%s)0x%" PRIx64 ")", GetTypeName().AsCString("void"),
                  GetValueAsUnsigned(0));
         return;
       } else {
         uint64_t load_addr =
             m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
         if (load_addr != LLDB_INVALID_ADDRESS) {
if (pointer_type) {
       lldb::DataBufferSP buffer(
           new lldb_private::DataBufferHeap(&address, sizeof(lldb::addr_t)));
       lldb::ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create(
           exe_ctx.GetBestExecutionContextScope(), pointer_type,
           ConstString(name), buffer, exe_ctx.GetByteOrder(),
           exe_ctx.GetAddressByteSize()));
       if (ptr_result_valobj_sp) {
         ptr_result_valobj_sp->GetValue().SetValueType(
-            Value::eValueTypeLoadAddress);
+            Value::ValueType::LoadAddress);
         Status err;
         ptr_result_valobj_sp = ptr_result_valobj_sp->Dereference(err);
         if (ptr_result_valobj_sp && !name.empty())
           ptr_result_valobj_sp->SetName(ConstString(name));
       }
       return ptr_result_valobj_sp;
     }
   }

lldb/source/Core/ValueObjectChild.cpp

if (parent->UpdateValueIfNeeded(false)) {
 
       if (parent->GetCompilerType().ShouldTreatScalarValueAsAddress()) {
         m_value.GetScalar() = parent->GetPointerValue();
 
         switch (parent->GetAddressTypeOfChildren()) {
         case eAddressTypeFile: {
           lldb::ProcessSP process_sp(GetProcessSP());
           if (process_sp && process_sp->IsAlive())
-            m_value.SetValueType(Value::eValueTypeLoadAddress);
+            m_value.SetValueType(Value::ValueType::LoadAddress);
           else
-            m_value.SetValueType(Value::eValueTypeFileAddress);
+            m_value.SetValueType(Value::ValueType::FileAddress);
         } break;
         case eAddressTypeLoad:
           m_value.SetValueType(is_instance_ptr_base
-                                   ? Value::eValueTypeScalar
-                                   : Value::eValueTypeLoadAddress);
+                                   ? Value::ValueType::Scalar
+                                   : Value::ValueType::LoadAddress);
           break;
         case eAddressTypeHost:
-          m_value.SetValueType(Value::eValueTypeHostAddress);
+          m_value.SetValueType(Value::ValueType::HostAddress);
           break;
         case eAddressTypeInvalid:
           // TODO: does this make sense?
-          m_value.SetValueType(Value::eValueTypeScalar);
+          m_value.SetValueType(Value::ValueType::Scalar);
           break;
         }
       }
       switch (m_value.GetValueType()) {
-      case Value::eValueTypeLoadAddress:
-      case Value::eValueTypeFileAddress:
-      case Value::eValueTypeHostAddress: {
+      case Value::ValueType::Invalid:
+        break;
+      case Value::ValueType::LoadAddress:
+      case Value::ValueType::FileAddress:
+      case Value::ValueType::HostAddress: {
         lldb::addr_t addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
         if (addr == LLDB_INVALID_ADDRESS) {
           m_error.SetErrorString("parent address is invalid.");
         } else if (addr == 0) {
           m_error.SetErrorString("parent is NULL");
         } else {
           // If a bitfield doesn't fit into the child_byte_size'd window at
           // child_byte_offset, move the window forward until it fits.  The
if (parent->UpdateValueIfNeeded(false)) {
           }
 
           // Set this object's scalar value to the address of its value by
           // adding its byte offset to the parent address
           m_value.GetScalar() += m_byte_offset;
         }
       } break;
 
-      case Value::eValueTypeScalar:
+      case Value::ValueType::Scalar:
         // try to extract the child value from the parent's scalar value
         {
           Scalar scalar(m_value.GetScalar());
           scalar.ExtractBitfield(8 * m_byte_size, 8 * m_byte_offset);
           m_value.GetScalar() = scalar;
         }
         break;
       }

lldb/source/Core/ValueObjectConstResult.cpp

ValueObjectConstResult::ValueObjectConstResult(
 
   if (!m_data.GetSharedDataBuffer()) {
     DataBufferSP shared_data_buffer(
         new DataBufferHeap(data.GetDataStart(), data.GetByteSize()));
     m_data.SetData(shared_data_buffer);
   }
 
   m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
-  m_value.SetValueType(Value::eValueTypeHostAddress);
+  m_value.SetValueType(Value::ValueType::HostAddress);
   m_value.SetCompilerType(compiler_type);
   m_name = name;
   SetIsConstant();
   SetValueIsValid(true);
   SetAddressTypeOfChildren(eAddressTypeLoad);
 }
 
 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
ValueObjectConstResult::ValueObjectConstResult(
     const CompilerType &compiler_type, ConstString name,
     const lldb::DataBufferSP &data_sp, lldb::ByteOrder data_byte_order,
     uint32_t data_addr_size, lldb::addr_t address)
     : ValueObject(exe_scope, manager), m_impl(this, address) {
   m_data.SetByteOrder(data_byte_order);
   m_data.SetAddressByteSize(data_addr_size);
   m_data.SetData(data_sp);
   m_value.GetScalar() = (uintptr_t)data_sp->GetBytes();
-  m_value.SetValueType(Value::eValueTypeHostAddress);
+  m_value.SetValueType(Value::ValueType::HostAddress);
   m_value.SetCompilerType(compiler_type);
   m_name = name;
   SetIsConstant();
   SetValueIsValid(true);
   SetAddressTypeOfChildren(eAddressTypeLoad);
 }
 
 ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
ValueObjectConstResult::ValueObjectConstResult(
     ExecutionContextScope *exe_scope, ValueObjectManager &manager,
     const CompilerType &compiler_type, ConstString name, lldb::addr_t address,
     AddressType address_type, uint32_t addr_byte_size)
     : ValueObject(exe_scope, manager), m_type_name(),
       m_impl(this, address) {
   m_value.GetScalar() = address;
   m_data.SetAddressByteSize(addr_byte_size);
   m_value.GetScalar().GetData(m_data, addr_byte_size);
-  // m_value.SetValueType(Value::eValueTypeHostAddress);
+  // m_value.SetValueType(Value::ValueType::HostAddress);
   switch (address_type) {
   case eAddressTypeInvalid:
-    m_value.SetValueType(Value::eValueTypeScalar);
+    m_value.SetValueType(Value::ValueType::Scalar);
     break;
   case eAddressTypeFile:
-    m_value.SetValueType(Value::eValueTypeFileAddress);
+    m_value.SetValueType(Value::ValueType::FileAddress);
     break;
   case eAddressTypeLoad:
-    m_value.SetValueType(Value::eValueTypeLoadAddress);
+    m_value.SetValueType(Value::ValueType::LoadAddress);
     break;
   case eAddressTypeHost:
-    m_value.SetValueType(Value::eValueTypeHostAddress);
+    m_value.SetValueType(Value::ValueType::HostAddress);
     break;
   }
   m_value.SetCompilerType(compiler_type);
   m_name = name;
   SetIsConstant();
   SetValueIsValid(true);
   SetAddressTypeOfChildren(eAddressTypeLoad);
 }

lldb/source/Core/ValueObjectConstResultImpl.cpp

if (m_live_address != LLDB_INVALID_ADDRESS) {
     std::string new_name("&");
     new_name.append(m_impl_backend->GetName().AsCString(""));
     ExecutionContext exe_ctx(m_impl_backend->GetExecutionContextRef());
     m_address_of_backend = ValueObjectConstResult::Create(
         exe_ctx.GetBestExecutionContextScope(), compiler_type.GetPointerType(),
         ConstString(new_name.c_str()), buffer, endian::InlHostByteOrder(),
         exe_ctx.GetAddressByteSize());
 
-    m_address_of_backend->GetValue().SetValueType(Value::eValueTypeScalar);
+    m_address_of_backend->GetValue().SetValueType(Value::ValueType::Scalar);
     m_address_of_backend->GetValue().GetScalar() = m_live_address;
 
     return m_address_of_backend;
   } else
     return m_impl_backend->ValueObject::AddressOf(error);
 }
 
 lldb::ValueObjectSP

lldb/source/Core/ValueObjectMemory.cpp

ValueObjectMemory::ValueObjectMemory(ExecutionContextScope *exe_scope,
                                      llvm::StringRef name,
                                      const Address &address,
                                      lldb::TypeSP &type_sp)
     : ValueObject(exe_scope, manager), m_address(address), m_type_sp(type_sp),
       m_compiler_type() {
   // Do not attempt to construct one of these objects with no variable!
   assert(m_type_sp.get() != nullptr);
   SetName(ConstString(name));
-  m_value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get());
+  m_value.SetContext(Value::ContextType::LLDBType, m_type_sp.get());
   TargetSP target_sp(GetTargetSP());
   lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
   if (load_address != LLDB_INVALID_ADDRESS) {
-    m_value.SetValueType(Value::eValueTypeLoadAddress);
+    m_value.SetValueType(Value::ValueType::LoadAddress);
     m_value.GetScalar() = load_address;
   } else {
     lldb::addr_t file_address = m_address.GetFileAddress();
     if (file_address != LLDB_INVALID_ADDRESS) {
-      m_value.SetValueType(Value::eValueTypeFileAddress);
+      m_value.SetValueType(Value::ValueType::FileAddress);
       m_value.GetScalar() = file_address;
     } else {
       m_value.GetScalar() = m_address.GetOffset();
-      m_value.SetValueType(Value::eValueTypeScalar);
+      m_value.SetValueType(Value::ValueType::Scalar);
     }
   }
 }
 
 ValueObjectMemory::ValueObjectMemory(ExecutionContextScope *exe_scope,
                                      ValueObjectManager &manager,
                                      llvm::StringRef name,
                                      const Address &address,
                                      const CompilerType &ast_type)
     : ValueObject(exe_scope, manager), m_address(address), m_type_sp(),
       m_compiler_type(ast_type) {
   // Do not attempt to construct one of these objects with no variable!
   assert(m_compiler_type.GetTypeSystem());
   assert(m_compiler_type.GetOpaqueQualType());
 
   TargetSP target_sp(GetTargetSP());
 
   SetName(ConstString(name));
   m_value.SetCompilerType(m_compiler_type);
   lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
   if (load_address != LLDB_INVALID_ADDRESS) {
-    m_value.SetValueType(Value::eValueTypeLoadAddress);
+    m_value.SetValueType(Value::ValueType::LoadAddress);
     m_value.GetScalar() = load_address;
   } else {
     lldb::addr_t file_address = m_address.GetFileAddress();
     if (file_address != LLDB_INVALID_ADDRESS) {
-      m_value.SetValueType(Value::eValueTypeFileAddress);
+      m_value.SetValueType(Value::ValueType::FileAddress);
       m_value.GetScalar() = file_address;
     } else {
       m_value.GetScalar() = m_address.GetOffset();
-      m_value.SetValueType(Value::eValueTypeScalar);
+      m_value.SetValueType(Value::ValueType::Scalar);
     }
   }
 }
 
 ValueObjectMemory::~ValueObjectMemory() {}
 
 CompilerType ValueObjectMemory::GetCompilerTypeImpl() {
   if (m_type_sp)
if (target) {
     m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
   }
 
   Value old_value(m_value);
   if (m_address.IsValid()) {
     Value::ValueType value_type = m_value.GetValueType();
 
     switch (value_type) {
-    case Value::eValueTypeScalar:
+    case Value::ValueType::Invalid:
+      m_error.SetErrorString("Invalid value");
+      return false;
+    case Value::ValueType::Scalar:
       // The variable value is in the Scalar value inside the m_value. We can
       // point our m_data right to it.
       m_error = m_value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
       break;
 
-    case Value::eValueTypeFileAddress:
-    case Value::eValueTypeLoadAddress:
-    case Value::eValueTypeHostAddress:
+    case Value::ValueType::FileAddress:
+    case Value::ValueType::LoadAddress:
+    case Value::ValueType::HostAddress:
       // The DWARF expression result was an address in the inferior process. If
       // this variable is an aggregate type, we just need the address as the
       // main value as all child variable objects will rely upon this location
       // and add an offset and then read their own values as needed. If this
       // variable is a simple type, we read all data for it into m_data. Make
       // sure this type has a value before we try and read it
 
       // If we have a file address, convert it to a load address if we can.
-      if (value_type == Value::eValueTypeFileAddress &&
+      if (value_type == Value::ValueType::FileAddress &&
           exe_ctx.GetProcessPtr()) {
         lldb::addr_t load_addr = m_address.GetLoadAddress(target);
         if (load_addr != LLDB_INVALID_ADDRESS) {
-          m_value.SetValueType(Value::eValueTypeLoadAddress);
+          m_value.SetValueType(Value::ValueType::LoadAddress);
           m_value.GetScalar() = load_addr;
         }
       }
 
       if (!CanProvideValue()) {
         // this value object represents an aggregate type whose children have
         // values, but this object does not. So we say we are changed if our
         // location has changed.
         SetValueDidChange(value_type != old_value.GetValueType() ||
                           m_value.GetScalar() != old_value.GetScalar());
       } else {
         // Copy the Value and set the context to use our Variable so it can
         // extract read its value into m_data appropriately
         Value value(m_value);
         if (m_type_sp)
-          value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get());
+          value.SetContext(Value::ContextType::LLDBType, m_type_sp.get());
         else {
           value.SetCompilerType(m_compiler_type);
         }
 
         m_error = value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
       }
       break;
     }

lldb/source/Core/ValueObjectRegister.cpp

bool ValueObjectRegister::UpdateValue() {
 
   if (m_reg_ctx_sp) {
     RegisterValue m_old_reg_value(m_reg_value);
     if (m_reg_ctx_sp->ReadRegister(&m_reg_info, m_reg_value)) {
       if (m_reg_value.GetData(m_data)) {
         Process *process = exe_ctx.GetProcessPtr();
         if (process)
           m_data.SetAddressByteSize(process->GetAddressByteSize());
-        m_value.SetContext(Value::eContextTypeRegisterInfo,
+        m_value.SetContext(Value::ContextType::RegisterInfo,
                            (void *)&m_reg_info);
-        m_value.SetValueType(Value::eValueTypeHostAddress);
+        m_value.SetValueType(Value::ValueType::HostAddress);
         m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
         SetValueIsValid(true);
         SetValueDidChange(!(m_old_reg_value == m_reg_value));
         return true;
       }
     }
   }
 

lldb/source/Core/ValueObjectVariable.cpp

bool ValueObjectVariable::UpdateValue() {
   DWARFExpression &expr = variable->LocationExpression();
 
   if (variable->GetLocationIsConstantValueData()) {
     // expr doesn't contain DWARF bytes, it contains the constant variable
     // value bytes themselves...
     if (expr.GetExpressionData(m_data)) {
        if (m_data.GetDataStart() && m_data.GetByteSize())
         m_value.SetBytes(m_data.GetDataStart(), m_data.GetByteSize());
-      m_value.SetContext(Value::eContextTypeVariable, variable);
+      m_value.SetContext(Value::ContextType::Variable, variable);
     }
     else
       m_error.SetErrorString("empty constant data");
     // constant bytes can't be edited - sorry
-    m_resolved_value.SetContext(Value::eContextTypeInvalid, nullptr);
+    m_resolved_value.SetContext(Value::ContextType::Invalid, nullptr);
   } else {
     lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;
     ExecutionContext exe_ctx(GetExecutionContextRef());
 
     Target *target = exe_ctx.GetTargetPtr();
     if (target) {
       m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
       m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
     }
 
     if (expr.IsLocationList()) {
       SymbolContext sc;
       variable->CalculateSymbolContext(&sc);
       if (sc.function)
         loclist_base_load_addr =
             sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
                 target);
     }
     Value old_value(m_value);
     if (expr.Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, nullptr,
                       nullptr, m_value, &m_error)) {
       m_resolved_value = m_value;
-      m_value.SetContext(Value::eContextTypeVariable, variable);
+      m_value.SetContext(Value::ContextType::Variable, variable);
 
       CompilerType compiler_type = GetCompilerType();
       if (compiler_type.IsValid())
         m_value.SetCompilerType(compiler_type);
 
       Value::ValueType value_type = m_value.GetValueType();
 
       // The size of the buffer within m_value can be less than the size
       // prescribed by its type. E.g. this can happen when an expression only
       // partially describes an object (say, because it contains DW_OP_piece).
       //
       // In this case, grow m_value to the expected size. An alternative way to
       // handle this is to teach Value::GetValueAsData() and ValueObjectChild
       // not to read past the end of a host buffer, but this gets impractically
       // complicated as a Value's host buffer may be shared with a distant
       // ancestor or sibling in the ValueObject hierarchy.
       //
       // FIXME: When we grow m_value, we should represent the added bits as
       // undefined somehow instead of as 0's.
-      if (value_type == Value::eValueTypeHostAddress &&
+      if (value_type == Value::ValueType::HostAddress &&
           compiler_type.IsValid()) {
         if (size_t value_buf_size = m_value.GetBuffer().GetByteSize()) {
           size_t value_size = m_value.GetValueByteSize(&m_error, &exe_ctx);
           if (m_error.Success() && value_buf_size < value_size)
             m_value.ResizeData(value_size);
         }
       }
 
       Process *process = exe_ctx.GetProcessPtr();
       const bool process_is_alive = process && process->IsAlive();
 
       switch (value_type) {
-      case Value::eValueTypeScalar:
+      case Value::ValueType::Invalid:
+        m_error.SetErrorString("invalid value");
+        break;
+      case Value::ValueType::Scalar:
         // The variable value is in the Scalar value inside the m_value. We can
         // point our m_data right to it.
         m_error =
             m_value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
         break;
 
-      case Value::eValueTypeFileAddress:
-      case Value::eValueTypeLoadAddress:
-      case Value::eValueTypeHostAddress:
+      case Value::ValueType::FileAddress:
+      case Value::ValueType::LoadAddress:
+      case Value::ValueType::HostAddress:
         // The DWARF expression result was an address in the inferior process.
         // If this variable is an aggregate type, we just need the address as
         // the main value as all child variable objects will rely upon this
         // location and add an offset and then read their own values as needed.
         // If this variable is a simple type, we read all data for it into
         // m_data. Make sure this type has a value before we try and read it
 
         // If we have a file address, convert it to a load address if we can.
-        if (value_type == Value::eValueTypeFileAddress && process_is_alive)
+        if (value_type == Value::ValueType::FileAddress && process_is_alive)
           m_value.ConvertToLoadAddress(GetModule().get(), target);
 
         if (!CanProvideValue()) {
           // this value object represents an aggregate type whose children have
           // values, but this object does not. So we say we are changed if our
           // location has changed.
           SetValueDidChange(value_type != old_value.GetValueType() ||
                             m_value.GetScalar() != old_value.GetScalar());
         } else {
           // Copy the Value and set the context to use our Variable so it can
           // extract read its value into m_data appropriately
           Value value(m_value);
-          value.SetContext(Value::eContextTypeVariable, variable);
+          value.SetContext(Value::ContextType::Variable, variable);
           m_error =
               value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
 
           SetValueDidChange(value_type != old_value.GetValueType() ||
                             m_value.GetScalar() != old_value.GetScalar());
         }
         break;
       }
 
       SetValueIsValid(m_error.Success());
     } else {
       // could not find location, won't allow editing
-      m_resolved_value.SetContext(Value::eContextTypeInvalid, nullptr);
+      m_resolved_value.SetContext(Value::ContextType::Invalid, nullptr);
     }
   }
   
   return m_error.Success();
 }
 
 void ValueObjectVariable::DoUpdateChildrenAddressType(ValueObject &valobj) {
   Value::ValueType value_type = valobj.GetValue().GetValueType();
   ExecutionContext exe_ctx(GetExecutionContextRef());
   Process *process = exe_ctx.GetProcessPtr();
   const bool process_is_alive = process && process->IsAlive();
   const uint32_t type_info = valobj.GetCompilerType().GetTypeInfo();
   const bool is_pointer_or_ref =
       (type_info & (lldb::eTypeIsPointer | lldb::eTypeIsReference)) != 0;
 
   switch (value_type) {
-  case Value::eValueTypeFileAddress:
+  case Value::ValueType::Invalid:
+    break;
+  case Value::ValueType::FileAddress:
     // If this type is a pointer, then its children will be considered load
     // addresses if the pointer or reference is dereferenced, but only if
     // the process is alive.
     //
     // There could be global variables like in the following code:
     // struct LinkedListNode { Foo* foo; LinkedListNode* next; };
     // Foo g_foo1;
     // Foo g_foo2;
     // LinkedListNode g_second_node = { &g_foo2, NULL };
     // LinkedListNode g_first_node = { &g_foo1, &g_second_node };
     //
     // When we aren't running, we should be able to look at these variables
     // using the "target variable" command. Children of the "g_first_node"
     // always will be of the same address type as the parent. But children
     // of the "next" member of LinkedListNode will become load addresses if
     // we have a live process, or remain a file address if it was a file
     // address.
     if (process_is_alive && is_pointer_or_ref)
       valobj.SetAddressTypeOfChildren(eAddressTypeLoad);
     else
       valobj.SetAddressTypeOfChildren(eAddressTypeFile);
     break;
-  case Value::eValueTypeHostAddress:
+  case Value::ValueType::HostAddress:
     // Same as above for load addresses, except children of pointer or refs
     // are always load addresses. Host addresses are used to store freeze
     // dried variables. If this type is a struct, the entire struct
     // contents will be copied into the heap of the
     // LLDB process, but we do not currently follow any pointers.
     if (is_pointer_or_ref)
       valobj.SetAddressTypeOfChildren(eAddressTypeLoad);
     else
       valobj.SetAddressTypeOfChildren(eAddressTypeHost);
     break;
-  case Value::eValueTypeLoadAddress:
-  case Value::eValueTypeScalar:
+  case Value::ValueType::LoadAddress:
+  case Value::ValueType::Scalar:
     valobj.SetAddressTypeOfChildren(eAddressTypeLoad);
     break;
   }
 }
 
 
 
 bool ValueObjectVariable::IsInScope() {
bool ValueObjectVariable::GetDeclaration(Declaration &decl) {
   if (m_variable_sp) {
     decl = m_variable_sp->GetDeclaration();
     return true;
   }
   return false;
 }
 
 const char *ValueObjectVariable::GetLocationAsCString() {
-  if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo)
+  if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo)
     return GetLocationAsCStringImpl(m_resolved_value, m_data);
   else
     return ValueObject::GetLocationAsCString();
 }
 
 bool ValueObjectVariable::SetValueFromCString(const char *value_str,
                                               Status &error) {
   if (!UpdateValueIfNeeded()) {
     error.SetErrorString("unable to update value before writing");
     return false;
   }
 
-  if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo) {
+  if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo) {
     RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo();
     ExecutionContext exe_ctx(GetExecutionContextRef());
     RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
     RegisterValue reg_value;
     if (!reg_info || !reg_ctx) {
       error.SetErrorString("unable to retrieve register info");
       return false;
     }

 }
 
 bool ValueObjectVariable::SetData(DataExtractor &data, Status &error) {
   if (!UpdateValueIfNeeded()) {
     error.SetErrorString("unable to update value before writing");
     return false;
   }
 
-  if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo) {
+  if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo) {
     RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo();
     ExecutionContext exe_ctx(GetExecutionContextRef());
     RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
     RegisterValue reg_value;
     if (!reg_info || !reg_ctx) {
       error.SetErrorString("unable to retrieve register info");
       return false;
     }

lldb/source/DataFormatters/TypeFormat.cpp

bool TypeFormatImpl_Format::FormatObject(ValueObject *valobj,
   if (!valobj)
     return false;
   if (valobj->CanProvideValue()) {
     Value &value(valobj->GetValue());
     const Value::ContextType context_type = value.GetContextType();
     ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
     DataExtractor data;
 
-    if (context_type == Value::eContextTypeRegisterInfo) {
+    if (context_type == Value::ContextType::RegisterInfo) {
       const RegisterInfo *reg_info = value.GetRegisterInfo();
       if (reg_info) {
         Status error;
         valobj->GetData(data, error);
         if (error.Fail())
           return false;
 
         StreamString reg_sstr;

lldb/source/Expression/DWARFExpression.cpp

if (native_reg == LLDB_INVALID_REGNUM) {
                                             "register number.\n",
                                             reg_kind, reg_num);
     } else {
       const RegisterInfo *reg_info =
           reg_ctx->GetRegisterInfoAtIndex(native_reg);
       RegisterValue reg_value;
       if (reg_ctx->ReadRegister(reg_info, reg_value)) {
         if (reg_value.GetScalarValue(value.GetScalar())) {
-          value.SetValueType(Value::eValueTypeScalar);
-          value.SetContext(Value::eContextTypeRegisterInfo,
+          value.SetValueType(Value::ValueType::Scalar);
+          value.SetContext(Value::ContextType::RegisterInfo,
                            const_cast<RegisterInfo *>(reg_info));
           if (error_ptr)
             error_ptr->Clear();
           return true;
         } else {
           // If we get this error, then we need to implement a value buffer in
           // the dwarf expression evaluation function...
           if (error_ptr)
if (log && log->GetVerbose()) {
                 DW_OP_value_to_name(op));
     }
 
     switch (op) {
     // The DW_OP_addr operation has a single operand that encodes a machine
     // address and whose size is the size of an address on the target machine.
     case DW_OP_addr:
       stack.push_back(Scalar(opcodes.GetAddress(&offset)));
-      stack.back().SetValueType(Value::eValueTypeFileAddress);
+      stack.back().SetValueType(Value::ValueType::FileAddress);
       // Convert the file address to a load address, so subsequent
       // DWARF operators can operate on it.
       if (frame)
         stack.back().ConvertToLoadAddress(module_sp.get(),
                                           frame->CalculateTarget().get());
       break;
 
     // The DW_OP_addr_sect_offset4 is used for any location expressions in
while (opcodes.ValidOffset(offset)) {
     case DW_OP_deref: {
       if (stack.empty()) {
         if (error_ptr)
           error_ptr->SetErrorString("Expression stack empty for DW_OP_deref.");
         return false;
       }
       Value::ValueType value_type = stack.back().GetValueType();
       switch (value_type) {
-      case Value::eValueTypeHostAddress: {
+      case Value::ValueType::HostAddress: {
         void *src = (void *)stack.back().GetScalar().ULongLong();
         intptr_t ptr;
         ::memcpy(&ptr, src, sizeof(void *));
         stack.back().GetScalar() = ptr;
         stack.back().ClearContext();
       } break;
-      case Value::eValueTypeFileAddress: {
+      case Value::ValueType::FileAddress: {
         auto file_addr = stack.back().GetScalar().ULongLong(
             LLDB_INVALID_ADDRESS);
         if (!module_sp) {
           if (error_ptr)
             error_ptr->SetErrorString(
                 "need module to resolve file address for DW_OP_deref");
           return false;
         }
         Address so_addr;
         if (!module_sp->ResolveFileAddress(file_addr, so_addr)) {
           if (error_ptr)
             error_ptr->SetErrorString(
                 "failed to resolve file address in module");
           return false;
         }
         addr_t load_Addr = so_addr.GetLoadAddress(exe_ctx->GetTargetPtr());
         if (load_Addr == LLDB_INVALID_ADDRESS) {
           if (error_ptr)
             error_ptr->SetErrorString("failed to resolve load address");
           return false;
         }
         stack.back().GetScalar() = load_Addr;
-        stack.back().SetValueType(Value::eValueTypeLoadAddress);
+        stack.back().SetValueType(Value::ValueType::LoadAddress);
         // Fall through to load address code below...
       } LLVM_FALLTHROUGH;
-      case Value::eValueTypeLoadAddress:
+      case Value::ValueType::LoadAddress:
         if (exe_ctx) {
           if (process) {
             lldb::addr_t pointer_addr =
                 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
             Status error;
             lldb::addr_t pointer_value =
                 process->ReadPointerFromMemory(pointer_addr, error);
             if (pointer_value != LLDB_INVALID_ADDRESS) {
case DW_OP_deref: {
         } else {
           if (error_ptr)
             error_ptr->SetErrorString(
                 "NULL execution context for DW_OP_deref.\n");
           return false;
         }
         break;
 
-      default:
+      case Value::ValueType::Scalar:
+      case Value::ValueType::Invalid:
         if (error_ptr)
-          error_ptr->SetErrorString("Unhandled value type for DW_OP_deref.\n");
+          error_ptr->SetErrorString("Invalid value type for DW_OP_deref.\n");
         return false;
       }
 
     } break;
 
     // OPCODE: DW_OP_deref_size
     // OPERANDS: 1
     //  1 - uint8_t that specifies the size of the data to dereference.
case DW_OP_deref_size: {
         if (error_ptr)
           error_ptr->SetErrorString(
               "Expression stack empty for DW_OP_deref_size.");
         return false;
       }
       uint8_t size = opcodes.GetU8(&offset);
       Value::ValueType value_type = stack.back().GetValueType();
       switch (value_type) {
-      case Value::eValueTypeHostAddress: {
+      case Value::ValueType::HostAddress: {
         void *src = (void *)stack.back().GetScalar().ULongLong();
         intptr_t ptr;
         ::memcpy(&ptr, src, sizeof(void *));
         // I can't decide whether the size operand should apply to the bytes in
         // their
         // lldb-host endianness or the target endianness.. I doubt this'll ever
         // come up but I'll opt for assuming big endian regardless.
         switch (size) {
case DW_OP_deref_size: {
           ptr = (intptr_t)ptr & 0xffffffffffffffULL;
           break;
         default:
           break;
         }
         stack.back().GetScalar() = ptr;
         stack.back().ClearContext();
       } break;
-      case Value::eValueTypeLoadAddress:
+      case Value::ValueType::LoadAddress:
         if (exe_ctx) {
           if (process) {
             lldb::addr_t pointer_addr =
                 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
             uint8_t addr_bytes[sizeof(lldb::addr_t)];
             Status error;
             if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) ==
                 size) {
case DW_OP_deref_size: {
                 error_ptr->SetErrorStringWithFormat(
                     "Failed to dereference pointer from 0x%" PRIx64
                     " for DW_OP_deref: %s\n",
                     pointer_addr, error.AsCString());
               return false;
             }
           } else {
             if (error_ptr)
-              error_ptr->SetErrorString("NULL process for DW_OP_deref.\n");
+              error_ptr->SetErrorString("NULL process for DW_OP_deref_size.\n");
             return false;
           }
         } else {
           if (error_ptr)
             error_ptr->SetErrorString(
-                "NULL execution context for DW_OP_deref.\n");
+                "NULL execution context for DW_OP_deref_size.\n");
           return false;
         }
         break;
 
-      default:
-        break;
+      case Value::ValueType::Scalar:
+      case Value::ValueType::FileAddress:
+      case Value::ValueType::Invalid:
+        if (error_ptr)
+          error_ptr->SetErrorString("Invalid value for DW_OP_deref_size.\n");
+        return false;
       }
 
     } break;
 
     // OPCODE: DW_OP_xderef_size
     // OPERANDS: 1
     //  1 - uint8_t that specifies the size of the data to dereference.
     // DESCRIPTION: Behaves like the DW_OP_xderef operation: the entry at
case DW_OP_breg31: {
       reg_num = op - DW_OP_breg0;
 
       if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr,
                                     tmp)) {
         int64_t breg_offset = opcodes.GetSLEB128(&offset);
         tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset;
         tmp.ClearContext();
         stack.push_back(tmp);
-        stack.back().SetValueType(Value::eValueTypeLoadAddress);
+        stack.back().SetValueType(Value::ValueType::LoadAddress);
       } else
         return false;
     } break;
     // OPCODE: DW_OP_bregx
     // OPERANDS: 2
     //      ULEB128 literal operand that encodes the register.
     //      SLEB128 offset from register N
     // DESCRIPTION: Value is in memory at the address specified by register
     // N plus an offset.
     case DW_OP_bregx: {
       reg_num = opcodes.GetULEB128(&offset);
 
       if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr,
                                     tmp)) {
         int64_t breg_offset = opcodes.GetSLEB128(&offset);
         tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset;
         tmp.ClearContext();
         stack.push_back(tmp);
-        stack.back().SetValueType(Value::eValueTypeLoadAddress);
+        stack.back().SetValueType(Value::ValueType::LoadAddress);
       } else
         return false;
     } break;
 
     case DW_OP_fbreg:
       if (exe_ctx) {
         if (frame) {
           Scalar value;
           if (frame->GetFrameBaseValue(value, error_ptr)) {
             int64_t fbreg_offset = opcodes.GetSLEB128(&offset);
             value += fbreg_offset;
             stack.push_back(value);
-            stack.back().SetValueType(Value::eValueTypeLoadAddress);
+            stack.back().SetValueType(Value::ValueType::LoadAddress);
           } else
             return false;
         } else {
           if (error_ptr)
             error_ptr->SetErrorString(
                 "Invalid stack frame in context for DW_OP_fbreg opcode.");
           return false;
         }
case DW_OP_piece: {
           Status error;
           // Extract the current piece into "curr_piece"
           Value curr_piece_source_value(stack.back());
           stack.pop_back();
 
           const Value::ValueType curr_piece_source_value_type =
               curr_piece_source_value.GetValueType();
           switch (curr_piece_source_value_type) {
-          case Value::eValueTypeLoadAddress:
+          case Value::ValueType::Invalid:
+            return false;
+          case Value::ValueType::LoadAddress:
             if (process) {
               if (curr_piece.ResizeData(piece_byte_size) == piece_byte_size) {
                 lldb::addr_t load_addr =
                     curr_piece_source_value.GetScalar().ULongLong(
                         LLDB_INVALID_ADDRESS);
                 if (process->ReadMemory(
                         load_addr, curr_piece.GetBuffer().GetBytes(),
                         piece_byte_size, error) != piece_byte_size) {
case DW_OP_piece: {
                       "failed to resize the piece memory buffer for "
                       "DW_OP_piece(%" PRIu64 ")",
                       piece_byte_size);
                 return false;
               }
             }
             break;
 
-          case Value::eValueTypeFileAddress:
-          case Value::eValueTypeHostAddress:
+          case Value::ValueType::FileAddress:
+          case Value::ValueType::HostAddress:
             if (error_ptr) {
               lldb::addr_t addr = curr_piece_source_value.GetScalar().ULongLong(
                   LLDB_INVALID_ADDRESS);
               error_ptr->SetErrorStringWithFormat(
                   "failed to read memory DW_OP_piece(%" PRIu64
                   ") from %s address 0x%" PRIx64,
                   piece_byte_size, curr_piece_source_value.GetValueType() ==
-                                           Value::eValueTypeFileAddress
+                                           Value::ValueType::FileAddress
                                        ? "file"
                                        : "host",
                   addr);
             }
             return false;
 
-          case Value::eValueTypeScalar: {
+          case Value::ValueType::Scalar: {
             uint32_t bit_size = piece_byte_size * 8;
             uint32_t bit_offset = 0;
             Scalar &scalar = curr_piece_source_value.GetScalar();
             if (!scalar.ExtractBitfield(
                     bit_size, bit_offset)) {
               if (error_ptr)
                 error_ptr->SetErrorStringWithFormat(
                     "unable to extract %" PRIu64 " bytes from a %" PRIu64
case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3);
         if (error_ptr)
           error_ptr->SetErrorString(
               "Expression stack needs at least 1 item for DW_OP_bit_piece.");
         return false;
       } else {
         const uint64_t piece_bit_size = opcodes.GetULEB128(&offset);
         const uint64_t piece_bit_offset = opcodes.GetULEB128(&offset);
         switch (stack.back().GetValueType()) {
-        case Value::eValueTypeScalar: {
+        case Value::ValueType::Invalid:
+          return false;
+        case Value::ValueType::Scalar: {
           if (!stack.back().GetScalar().ExtractBitfield(piece_bit_size,
                                                         piece_bit_offset)) {
             if (error_ptr)
               error_ptr->SetErrorStringWithFormat(
                   "unable to extract %" PRIu64 " bit value with %" PRIu64
                   " bit offset from a %" PRIu64 " bit scalar value.",
                   piece_bit_size, piece_bit_offset,
                   (uint64_t)(stack.back().GetScalar().GetByteSize() * 8));
             return false;
           }
         } break;
 
-        case Value::eValueTypeFileAddress:
-        case Value::eValueTypeLoadAddress:
-        case Value::eValueTypeHostAddress:
+        case Value::ValueType::FileAddress:
+        case Value::ValueType::LoadAddress:
+        case Value::ValueType::HostAddress:
           if (error_ptr) {
             error_ptr->SetErrorStringWithFormat(
                 "unable to extract DW_OP_bit_piece(bit_size = %" PRIu64
                 ", bit_offset = %" PRIu64 ") from an address value.",
                 piece_bit_size, piece_bit_offset);
           }
           return false;
         }

     // value to be used.  This is the actual object value and not the location.
     case DW_OP_stack_value:
       if (stack.empty()) {
         if (error_ptr)
           error_ptr->SetErrorString(
               "Expression stack needs at least 1 item for DW_OP_stack_value.");
         return false;
       }
-      stack.back().SetValueType(Value::eValueTypeScalar);
+      stack.back().SetValueType(Value::ValueType::Scalar);
       break;
 
     // OPCODE: DW_OP_convert
     // OPERANDS: 1
     //      A ULEB128 that is either a DIE offset of a
     //      DW_TAG_base_type or 0 for the generic (pointer-sized) type.
     //
     // DESCRIPTION: Pop the top stack element, convert it to a

     case DW_OP_call_frame_cfa:
       if (frame) {
         // Note that we don't have to parse FDEs because this DWARF expression
         // is commonly evaluated with a valid stack frame.
         StackID id = frame->GetStackID();
         addr_t cfa = id.GetCallFrameAddress();
         if (cfa != LLDB_INVALID_ADDRESS) {
           stack.push_back(Scalar(cfa));
-          stack.back().SetValueType(Value::eValueTypeLoadAddress);
+          stack.back().SetValueType(Value::ValueType::LoadAddress);
         } else if (error_ptr)
           error_ptr->SetErrorString("Stack frame does not include a canonical "
                                     "frame address for DW_OP_call_frame_cfa "
                                     "opcode.");
       } else {
         if (error_ptr)
           error_ptr->SetErrorString("Invalid stack frame in context for "
                                     "DW_OP_call_frame_cfa opcode.");
case DW_OP_GNU_push_tls_address: {
       if (tls_load_addr == LLDB_INVALID_ADDRESS) {
         if (error_ptr)
           error_ptr->SetErrorString(
               "No TLS data currently exists for this thread.");
         return false;
       }
 
       stack.back().GetScalar() = tls_load_addr;
-      stack.back().SetValueType(Value::eValueTypeLoadAddress);
+      stack.back().SetValueType(Value::ValueType::LoadAddress);
     } break;
 
     // OPCODE: DW_OP_addrx (DW_OP_GNU_addr_index is the legacy name.)
     // OPERANDS: 1
     //      ULEB128: index to the .debug_addr section
     // DESCRIPTION: Pushes an address to the stack from the .debug_addr
     // section with the base address specified by the DW_AT_addr_base attribute
     // and the 0 based index is the ULEB128 encoded index.
     case DW_OP_addrx:
     case DW_OP_GNU_addr_index: {
       if (!dwarf_cu) {
         if (error_ptr)
           error_ptr->SetErrorString("DW_OP_GNU_addr_index found without a "
                                     "compile unit being specified");
         return false;
       }
       uint64_t index = opcodes.GetULEB128(&offset);
       lldb::addr_t value = ReadAddressFromDebugAddrSection(dwarf_cu, index);
       stack.push_back(Scalar(value));
-      stack.back().SetValueType(Value::eValueTypeFileAddress);
+      stack.back().SetValueType(Value::ValueType::FileAddress);
     } break;
 
     // OPCODE: DW_OP_GNU_const_index
     // OPERANDS: 1
     //      ULEB128: index to the .debug_addr section
     // DESCRIPTION: Pushes an constant with the size of a machine address to
     // the stack from the .debug_addr section with the base address specified
     // by the DW_AT_addr_base attribute and the 0 based index is the ULEB128

lldb/source/Expression/FunctionCaller.cpp

for (size_t i = 0; i < num_args; i++) {
     uint64_t offset = m_member_offsets[i + 1]; // Clang sizes are in bytes.
     Value *arg_value = arg_values.GetValueAtIndex(i);
 
     // FIXME: For now just do scalars:
 
     // Special case: if it's a pointer, don't do anything (the ABI supports
     // passing cstrings)
 
-    if (arg_value->GetValueType() == Value::eValueTypeHostAddress &&
-        arg_value->GetContextType() == Value::eContextTypeInvalid &&
+    if (arg_value->GetValueType() == Value::ValueType::HostAddress &&
+        arg_value->GetContextType() == Value::ContextType::Invalid &&
         arg_value->GetCompilerType().IsPointerType())
       continue;
 
     const Scalar &arg_scalar = arg_value->ResolveValue(&exe_ctx);
 
     if (!process->WriteScalarToMemory(args_addr_ref + offset, arg_scalar,
                                       arg_scalar.GetByteSize(), error))
       return false;
bool FunctionCaller::FetchFunctionResults(ExecutionContext &exe_ctx,
   Status error;
   ret_value.GetScalar() = process->ReadUnsignedIntegerFromMemory(
       args_addr + m_return_offset, m_return_size, 0, error);
 
   if (error.Fail())
     return false;
 
   ret_value.SetCompilerType(m_function_return_type);
-  ret_value.SetValueType(Value::eValueTypeScalar);
+  ret_value.SetValueType(Value::ValueType::Scalar);
   return true;
 }
 
 void FunctionCaller::DeallocateFunctionResults(ExecutionContext &exe_ctx,
                                                lldb::addr_t args_addr) {
   std::list<lldb::addr_t>::iterator pos;
   pos = std::find(m_wrapper_args_addrs.begin(), m_wrapper_args_addrs.end(),
                   args_addr);

lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.cpp

ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl(
 
   llvm::Optional<uint64_t> byte_size =
       return_compiler_type.GetByteSize(&thread);
   if (!byte_size)
     return return_valobj_sp;
 
   const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
   if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
       // Extract the register context so we can read arguments from registers
       if (*byte_size <= 8) {
         const RegisterInfo *x0_reg_info =
             reg_ctx->GetRegisterInfoByName("x0", 0);
         if (x0_reg_info) {

lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.cpp

ValueObjectSP ABISysV_arm64::GetReturnValueObjectImpl(
 
   llvm::Optional<uint64_t> byte_size =
       return_compiler_type.GetByteSize(&thread);
   if (!byte_size)
     return return_valobj_sp;
 
   const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
   if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
       // Extract the register context so we can read arguments from registers
       if (*byte_size <= 8) {
         const RegisterInfo *x0_reg_info = nullptr;
         x0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
                                                LLDB_REGNUM_GENERIC_ARG1);

lldb/source/Plugins/ABI/X86/ABISysV_i386.cpp

ValueObjectSP ABISysV_i386::GetReturnValueObjectSimple(
   // The terminology 'Fundamental Data Types' used here is adopted from Table
   // 2.1 of the reference document (specified on top of this file)
 
   if (type_flags & eTypeIsPointer) // 'Pointer'
   {
     uint32_t ptr =
         thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
         0xffffffff;
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
     value.GetScalar() = ptr;
     return_valobj_sp = ValueObjectConstResult::Create(
         thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if ((type_flags & eTypeIsScalar) ||
              (type_flags & eTypeIsEnumeration)) //'Integral' + 'Floating Point'
   {
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
     llvm::Optional<uint64_t> byte_size =
         return_compiler_type.GetByteSize(&thread);
     if (!byte_size)
       return return_valobj_sp;
     bool success = false;
 
     if (type_flags & eTypeIsInteger) // 'Integral' except enum
     {
if (type_flags & eTypeIsInteger) // 'Integral' except enum
       if (success)
         return_valobj_sp = ValueObjectConstResult::Create(
             thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
     } else if (type_flags & eTypeIsEnumeration) // handles enum
     {
       uint32_t enm =
           thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
           0xffffffff;
-      value.SetValueType(Value::eValueTypeScalar);
+      value.SetValueType(Value::ValueType::Scalar);
       value.GetScalar() = enm;
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
     } else if (type_flags & eTypeIsFloat) // 'Floating Point'
     {
       if (*byte_size <= 12) // handles float, double, long double, __float80
       {
         const RegisterInfo *st0_info = reg_ctx->GetRegisterInfoByName("st0", 0);

lldb/source/Plugins/ABI/X86/ABISysV_x86_64.cpp

ValueObjectSP ABISysV_x86_64::GetReturnValueObjectSimple(
   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::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger) {
       // Extract the register context so we can read arguments from registers
 
       llvm::Optional<uint64_t> byte_size =
           return_compiler_type.GetByteSize(&thread);
       if (!byte_size)
if (success)
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsPointer) {
     unsigned rax_id =
         reg_ctx->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
     value.GetScalar() =
         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
                                                                       0);
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
     return_valobj_sp = ValueObjectConstResult::Create(
         thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsVector) {
     llvm::Optional<uint64_t> byte_size =
         return_compiler_type.GetByteSize(&thread);
     if (byte_size && *byte_size > 0) {
       const RegisterInfo *altivec_reg =
           reg_ctx->GetRegisterInfoByName("xmm0", 0);

lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.cpp

ValueObjectSP ABIWindows_x86_64::GetReturnValueObjectSimple(
   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::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger) {
       // Extract the register context so we can read arguments from registers
       llvm::Optional<uint64_t> byte_size =
           return_compiler_type.GetByteSize(&thread);
       if (!byte_size)
         return return_valobj_sp;
if (success)
           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::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
     return_valobj_sp = ValueObjectConstResult::Create(
         thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsVector) {
     llvm::Optional<uint64_t> byte_size =
         return_compiler_type.GetByteSize(&thread);
     if (byte_size && *byte_size > 0) {
       const RegisterInfo *xmm_reg =
           reg_ctx->GetRegisterInfoByName("xmm0", 0);

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

CompilerType clang_void_ptr_type =
         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
     CompilerType clang_uint32_type =
         clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
             lldb::eEncodingUint, 32);
     CompilerType clang_uint64_type =
         clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
             lldb::eEncodingUint, 32);
 
-    mode_value.SetValueType(Value::eValueTypeScalar);
+    mode_value.SetValueType(Value::ValueType::Scalar);
     mode_value.SetCompilerType(clang_uint32_type);
 
     if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 4) {
-      count_value.SetValueType(Value::eValueTypeScalar);
+      count_value.SetValueType(Value::ValueType::Scalar);
       count_value.SetCompilerType(clang_uint32_type);
     } else {
-      count_value.SetValueType(Value::eValueTypeScalar);
+      count_value.SetValueType(Value::ValueType::Scalar);
       count_value.SetCompilerType(clang_uint64_type);
     }
 
-    headers_value.SetValueType(Value::eValueTypeScalar);
+    headers_value.SetValueType(Value::ValueType::Scalar);
     headers_value.SetCompilerType(clang_void_ptr_type);
 
     argument_values.PushValue(mode_value);
     argument_values.PushValue(count_value);
     argument_values.PushValue(headers_value);
 
     if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
       uint32_t dyld_mode =

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

if (abi) {
     ValueList argument_values;
     Value input_value;
 
     CompilerType clang_void_ptr_type =
         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
     CompilerType clang_uint32_type =
         clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
             lldb::eEncodingUint, 32);
-    input_value.SetValueType(Value::eValueTypeScalar);
+    input_value.SetValueType(Value::ValueType::Scalar);
     input_value.SetCompilerType(clang_uint32_type);
     //        input_value.SetContext (Value::eContextTypeClangType,
     //        clang_uint32_type);
     argument_values.PushValue(input_value);
     argument_values.PushValue(input_value);
     input_value.SetCompilerType(clang_void_ptr_type);
     //        input_value.SetContext (Value::eContextTypeClangType,
     //        clang_void_ptr_type);

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
   Status err;
 
   if (var->GetLocationIsConstantValueData()) {
     DataExtractor const_value_extractor;
 
     if (var_location_expr.GetExpressionData(const_value_extractor)) {
       var_location = Value(const_value_extractor.GetDataStart(),
                            const_value_extractor.GetByteSize());
-      var_location.SetValueType(Value::eValueTypeHostAddress);
+      var_location.SetValueType(Value::ValueType::HostAddress);
     } else {
       LLDB_LOG(log, "Error evaluating constant variable: {0}", err.AsCString());
       return false;
     }
   }
 
   CompilerType type_to_use = GuardedCopyType(var_clang_type);
 
   if (!type_to_use) {
     LLDB_LOG(log,
              "Couldn't copy a variable's type into the parser's AST context");
 
     return false;
   }
 
   if (parser_type)
     *parser_type = TypeFromParser(type_to_use);
 
-  if (var_location.GetContextType() == Value::eContextTypeInvalid)
+  if (var_location.GetContextType() == Value::ContextType::Invalid)
     var_location.SetCompilerType(type_to_use);
 
-  if (var_location.GetValueType() == Value::eValueTypeFileAddress) {
+  if (var_location.GetValueType() == Value::ValueType::FileAddress) {
     SymbolContext var_sc;
     var->CalculateSymbolContext(&var_sc);
 
     if (!var_sc.module_sp)
       return false;
 
     Address so_addr(var_location.GetScalar().ULongLong(),
                     var_sc.module_sp->GetSectionList());
 
     lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
 
     if (load_addr != LLDB_INVALID_ADDRESS) {
       var_location.GetScalar() = load_addr;
-      var_location.SetValueType(Value::eValueTypeLoadAddress);
+      var_location.SetValueType(Value::ValueType::LoadAddress);
     }
   }
 
   if (user_type)
     *user_type = TypeFromUser(var_clang_type);
 
   return true;
 }
void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
 
   entity->EnableParserVars(GetParserID());
   ClangExpressionVariable::ParserVars *parser_vars =
       entity->GetParserVars(GetParserID());
 
   const Address symbol_address = symbol.GetAddress();
   lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);
 
-  // parser_vars->m_lldb_value.SetContext(Value::eContextTypeClangType,
+  // parser_vars->m_lldb_value.SetContext(Value::ContextType::ClangType,
   // user_type.GetOpaqueQualType());
   parser_vars->m_lldb_value.SetCompilerType(user_type);
   parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
-  parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
+  parser_vars->m_lldb_value.SetValueType(Value::ValueType::LoadAddress);
 
   parser_vars->m_named_decl = var_decl;
   parser_vars->m_llvm_value = nullptr;
   parser_vars->m_lldb_sym = &symbol;
 
   LLDB_LOG(log, "  CEDM::FEVD Found variable {1}, returned\n{2}", decl_name,
            ClangUtil::DumpDecl(var_decl));
 }
void ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
   entity->SetName(ConstString(decl_name.c_str()));
   entity->SetCompilerType(function_clang_type);
   entity->EnableParserVars(GetParserID());
 
   ClangExpressionVariable::ParserVars *parser_vars =
       entity->GetParserVars(GetParserID());
 
   if (load_addr != LLDB_INVALID_ADDRESS) {
-    parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
+    parser_vars->m_lldb_value.SetValueType(Value::ValueType::LoadAddress);
     parser_vars->m_lldb_value.GetScalar() = load_addr;
   } else {
     // We have to try finding a file address.
 
     lldb::addr_t file_addr = fun_address.GetFileAddress();
 
-    parser_vars->m_lldb_value.SetValueType(Value::eValueTypeFileAddress);
+    parser_vars->m_lldb_value.SetValueType(Value::ValueType::FileAddress);
     parser_vars->m_lldb_value.GetScalar() = file_addr;
   }
 
   parser_vars->m_named_decl = function_decl;
   parser_vars->m_llvm_value = nullptr;
 
   if (log) {
     StreamString ss;

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

bool ItaniumABILanguageRuntime::GetDynamicTypeAndAddress(
   // vtable (not the beginning of the vtable.)  We can then look up the symbol
   // containing this "address point" and that symbol's name demangled will
   // contain the full class name. The second pointer above the "address point"
   // is the "offset_to_top".  We'll use that to get the start of the value
   // object which holds the dynamic type.
   //
 
   class_type_or_name.Clear();
-  value_type = Value::ValueType::eValueTypeScalar;
+  value_type = Value::ValueType::Scalar;
 
   // Only a pointer or reference type can have a different dynamic and static
   // type:
   if (!CouldHaveDynamicValue(in_value))
     return false;
 
   // First job, pull out the address at 0 offset from the object.
   AddressType address_type;

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

 
 // for V1 runtime we just try to return a class name as that is the minimum
 // level of support required for the data formatters to work
 bool AppleObjCRuntimeV1::GetDynamicTypeAndAddress(
     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
     TypeAndOrName &class_type_or_name, Address &address,
     Value::ValueType &value_type) {
   class_type_or_name.Clear();
-  value_type = Value::ValueType::eValueTypeScalar;
+  value_type = Value::ValueType::Scalar;
   if (CouldHaveDynamicValue(in_value)) {
     auto class_descriptor(GetClassDescriptor(in_value));
     if (class_descriptor && class_descriptor->IsValid() &&
         class_descriptor->GetClassName()) {
       const addr_t object_ptr = in_value.GetPointerValue();
       address.SetRawAddress(object_ptr);
       class_type_or_name.SetName(class_descriptor->GetClassName());
     }

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress(
 
   Process *process = in_value.GetProcessSP().get();
   if (process)
     assert(process == m_process);
   else
     assert(in_value.GetTargetSP().get() == m_process->CalculateTarget().get());
 
   class_type_or_name.Clear();
-  value_type = Value::ValueType::eValueTypeScalar;
+  value_type = Value::ValueType::Scalar;
 
   // Make sure we can have a dynamic value before starting...
   if (CouldHaveDynamicValue(in_value)) {
     // First job, pull out the address at 0 offset from the object  That will
     // be the ISA pointer.
     ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(in_value));
     if (objc_class_sp) {
       const addr_t object_ptr = in_value.GetPointerValue();
if (!utility_fn_or_error) {
           log, utility_fn_or_error.takeError(),
           "Failed to get utility function for implementation lookup: {0}");
       return DescriptorMapUpdateResult::Fail();
     }
     m_get_class_info_code = std::move(*utility_fn_or_error);
 
     // Next make the runner function for our implementation utility function.
     Value value;
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
     value.SetCompilerType(clang_void_pointer_type);
     arguments.PushValue(value);
     arguments.PushValue(value);
 
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
     value.SetCompilerType(clang_uint32_t_type);
     arguments.PushValue(value);
     arguments.PushValue(value);
 
     Status error;
     get_class_info_function = m_get_class_info_code->MakeFunctionCaller(
         clang_uint32_t_type, arguments, thread_sp, error);
 
if (get_class_info_function->WriteFunctionArguments(
     options.SetUnwindOnError(true);
     options.SetTryAllThreads(false);
     options.SetStopOthers(true);
     options.SetIgnoreBreakpoints(true);
     options.SetTimeout(process->GetUtilityExpressionTimeout());
     options.SetIsForUtilityExpr(true);
 
     Value return_value;
-    return_value.SetValueType(Value::eValueTypeScalar);
+    return_value.SetValueType(Value::ValueType::Scalar);
     return_value.SetCompilerType(clang_uint32_t_type);
     return_value.GetScalar() = 0;
 
     diagnostics.Clear();
 
     // Run the function
     ExpressionResults results = get_class_info_function->ExecuteFunction(
         exe_ctx, &m_get_class_info_args, options, diagnostics, return_value);
if (!utility_fn_or_error) {
           "Failed to get utility function for implementation lookup: {0}");
       return DescriptorMapUpdateResult::Fail();
     }
 
     m_get_shared_cache_class_info_code = std::move(*utility_fn_or_error);
 
     // Next make the function caller for our implementation utility function.
     Value value;
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
     value.SetCompilerType(clang_void_pointer_type);
     arguments.PushValue(value);
     arguments.PushValue(value);
 
-    value.SetValueType(Value::eValueTypeScalar);
+    value.SetValueType(Value::ValueType::Scalar);
     value.SetCompilerType(clang_uint32_t_type);
     arguments.PushValue(value);
     arguments.PushValue(value);
 
     get_shared_cache_class_info_function =
         m_get_shared_cache_class_info_code->MakeFunctionCaller(
             clang_uint32_t_type, arguments, thread_sp, error);
 
if (get_shared_cache_class_info_function->WriteFunctionArguments(
     options.SetUnwindOnError(true);
     options.SetTryAllThreads(false);
     options.SetStopOthers(true);
     options.SetIgnoreBreakpoints(true);
     options.SetTimeout(process->GetUtilityExpressionTimeout());
     options.SetIsForUtilityExpr(true);
 
     Value return_value;
-    return_value.SetValueType(Value::eValueTypeScalar);
+    return_value.SetValueType(Value::ValueType::Scalar);
     return_value.SetCompilerType(clang_uint32_t_type);
     return_value.GetScalar() = 0;
 
     diagnostics.Clear();
 
     // Run the function
     ExpressionResults results =
         get_shared_cache_class_info_function->ExecuteFunction(

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

if (vtable_handler->InitializeVTableSymbols()) {
     if (!clang_ast_context)
       return false;
 
     ValueList argument_values;
     Value input_value;
     CompilerType clang_void_ptr_type =
         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
 
-    input_value.SetValueType(Value::eValueTypeScalar);
+    input_value.SetValueType(Value::ValueType::Scalar);
     // input_value.SetContext (Value::eContextTypeClangType,
     // clang_void_ptr_type);
     input_value.SetCompilerType(clang_void_ptr_type);
     argument_values.PushValue(input_value);
 
     bool success =
         abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values);
     if (!success)
TypeSystemClang *clang_ast_context =
         ScratchTypeSystemClang::GetForTarget(*target_sp);
     if (!clang_ast_context)
       return ret_plan_sp;
 
     ValueList argument_values;
     Value void_ptr_value;
     CompilerType clang_void_ptr_type =
         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
-    void_ptr_value.SetValueType(Value::eValueTypeScalar);
+    void_ptr_value.SetValueType(Value::ValueType::Scalar);
     // void_ptr_value.SetContext (Value::eContextTypeClangType,
     // clang_void_ptr_type);
     void_ptr_value.SetCompilerType(clang_void_ptr_type);
 
     int obj_index;
     int sel_index;
 
     // If this is a struct return dispatch, then the first argument is
if (this_dispatch->is_super) {
 
       // Note, it isn't a fatal error not to be able to get the
       // address from the object, since this might be a "tagged
       // pointer" which isn't a real object, but rather some word
       // length encoded dingus.
 
       Value isa_value(*(argument_values.GetValueAtIndex(obj_index)));
 
-      isa_value.SetValueType(Value::eValueTypeLoadAddress);
+      isa_value.SetValueType(Value::ValueType::LoadAddress);
       isa_value.ResolveValue(&exe_ctx);
       if (isa_value.GetScalar().IsValid()) {
         isa_addr = isa_value.GetScalar().ULongLong();
       } else {
         LLDB_LOGF(log, "Failed to extract the isa value from object.");
       }
     }
 
if (impl_addr != LLDB_INVALID_ADDRESS) {
 
       dispatch_values.PushValue(*(argument_values.GetValueAtIndex(obj_index)));
       dispatch_values.PushValue(*(argument_values.GetValueAtIndex(sel_index)));
 
       Value flag_value;
       CompilerType clang_int_type =
           clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
               lldb::eEncodingSint, 32);
-      flag_value.SetValueType(Value::eValueTypeScalar);
+      flag_value.SetValueType(Value::ValueType::Scalar);
       // flag_value.SetContext (Value::eContextTypeClangType, clang_int_type);
       flag_value.SetCompilerType(clang_int_type);
 
       if (this_dispatch->stret_return)
         flag_value.GetScalar() = 1;
       else
         flag_value.GetScalar() = 0;
       dispatch_values.PushValue(flag_value);

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

PlatformPOSIX::MakeLoadImageUtilityFunction(ExecutionContext &exe_ctx,
   CompilerType clang_void_pointer_type
       = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
   CompilerType clang_char_pointer_type
         = ast->GetBasicType(eBasicTypeChar).GetPointerType();
 
   // We are passing four arguments, the basename, the list of places to look,
   // a buffer big enough for all the path + name combos, and
   // a pointer to the storage we've made for the result:
-  value.SetValueType(Value::eValueTypeScalar);
+  value.SetValueType(Value::ValueType::Scalar);
   value.SetCompilerType(clang_void_pointer_type);
   arguments.PushValue(value);
   value.SetCompilerType(clang_char_pointer_type);
   arguments.PushValue(value);
   arguments.PushValue(value);
   arguments.PushValue(value);
   
   do_dlopen_function = dlopen_utility_func_up->MakeFunctionCaller(

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
if (module_sp) {
               VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
               if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
                 const DWARFExpression &location = var_sp->LocationExpression();
                 Value location_result;
                 Status error;
                 if (location.Evaluate(nullptr, LLDB_INVALID_ADDRESS, nullptr,
                                       nullptr, location_result, &error)) {
                   if (location_result.GetValueType() ==
-                      Value::eValueTypeFileAddress) {
+                      Value::ValueType::FileAddress) {
                     lldb::addr_t file_addr =
                         location_result.GetScalar().ULongLong();
                     lldb::addr_t byte_size = 1;
                     if (var_sp->GetType())
                       byte_size =
                           var_sp->GetType()->GetByteSize(nullptr).getValueOr(0);
                     m_global_aranges_up->Append(GlobalVariableMap::Entry(
                         file_addr, byte_size, var_sp.get()));

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

AppleGetItemInfoHandler::GetItemInfo(Thread &thread, uint64_t item,
   //                                             uint64_t page_to_free_size)
 
   // Where the return_buffer argument points to a 24 byte region of memory
   // already allocated by lldb in the inferior process.
 
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
   Value return_buffer_ptr_value;
-  return_buffer_ptr_value.SetValueType(Value::eValueTypeScalar);
+  return_buffer_ptr_value.SetValueType(Value::ValueType::Scalar);
   return_buffer_ptr_value.SetCompilerType(clang_void_ptr_type);
 
   CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
   Value debug_value;
-  debug_value.SetValueType(Value::eValueTypeScalar);
+  debug_value.SetValueType(Value::ValueType::Scalar);
   debug_value.SetCompilerType(clang_int_type);
 
   CompilerType clang_uint64_type =
       clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
   Value item_value;
-  item_value.SetValueType(Value::eValueTypeScalar);
+  item_value.SetValueType(Value::ValueType::Scalar);
   item_value.SetCompilerType(clang_uint64_type);
 
   Value page_to_free_value;
-  page_to_free_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_value.SetValueType(Value::ValueType::Scalar);
   page_to_free_value.SetCompilerType(clang_void_ptr_type);
 
   Value page_to_free_size_value;
-  page_to_free_size_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_size_value.SetValueType(Value::ValueType::Scalar);
   page_to_free_size_value.SetCompilerType(clang_uint64_type);
 
   std::lock_guard<std::mutex> guard(m_get_item_info_retbuffer_mutex);
   if (m_get_item_info_return_buffer_addr == LLDB_INVALID_ADDRESS) {
     addr_t bufaddr = process_sp->AllocateMemory(
         32, ePermissionsReadable | ePermissionsWritable, error);
     if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS) {
       LLDB_LOGF(log, "Failed to allocate memory for return buffer for get "

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

AppleGetPendingItemsHandler::GetPendingItems(Thread &thread, addr_t queue,
   //                                             uint64_t page_to_free_size)
 
   // Where the return_buffer argument points to a 24 byte region of memory
   // already allocated by lldb in the inferior process.
 
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
   Value return_buffer_ptr_value;
-  return_buffer_ptr_value.SetValueType(Value::eValueTypeScalar);
+  return_buffer_ptr_value.SetValueType(Value::ValueType::Scalar);
   return_buffer_ptr_value.SetCompilerType(clang_void_ptr_type);
 
   CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
   Value debug_value;
-  debug_value.SetValueType(Value::eValueTypeScalar);
+  debug_value.SetValueType(Value::ValueType::Scalar);
   debug_value.SetCompilerType(clang_int_type);
 
   CompilerType clang_uint64_type =
       clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
   Value queue_value;
-  queue_value.SetValueType(Value::eValueTypeScalar);
+  queue_value.SetValueType(Value::ValueType::Scalar);
   queue_value.SetCompilerType(clang_uint64_type);
 
   Value page_to_free_value;
-  page_to_free_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_value.SetValueType(Value::ValueType::Scalar);
   page_to_free_value.SetCompilerType(clang_void_ptr_type);
 
   Value page_to_free_size_value;
-  page_to_free_size_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_size_value.SetValueType(Value::ValueType::Scalar);
   page_to_free_size_value.SetCompilerType(clang_uint64_type);
 
   std::lock_guard<std::mutex> guard(m_get_pending_items_retbuffer_mutex);
   if (m_get_pending_items_return_buffer_addr == LLDB_INVALID_ADDRESS) {
     addr_t bufaddr = process_sp->AllocateMemory(
         32, ePermissionsReadable | ePermissionsWritable, error);
     if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS) {
       LLDB_LOGF(log, "Failed to allocate memory for return buffer for get "

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

AppleGetQueuesHandler::GetCurrentQueues(Thread &thread, addr_t page_to_free,
   //                                          uint64_t page_to_free_size);
 
   // Where the return_buffer argument points to a 24 byte region of memory
   // already allocated by lldb in the inferior process.
 
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
   Value return_buffer_ptr_value;
-  return_buffer_ptr_value.SetValueType(Value::eValueTypeScalar);
+  return_buffer_ptr_value.SetValueType(Value::ValueType::Scalar);
   return_buffer_ptr_value.SetCompilerType(clang_void_ptr_type);
 
   CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
   Value debug_value;
-  debug_value.SetValueType(Value::eValueTypeScalar);
+  debug_value.SetValueType(Value::ValueType::Scalar);
   debug_value.SetCompilerType(clang_int_type);
 
   Value page_to_free_value;
-  page_to_free_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_value.SetValueType(Value::ValueType::Scalar);
   page_to_free_value.SetCompilerType(clang_void_ptr_type);
 
   CompilerType clang_uint64_type =
       clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
   Value page_to_free_size_value;
-  page_to_free_size_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_size_value.SetValueType(Value::ValueType::Scalar);
   page_to_free_size_value.SetCompilerType(clang_uint64_type);
 
   std::lock_guard<std::mutex> guard(m_get_queues_retbuffer_mutex);
   if (m_get_queues_return_buffer_addr == LLDB_INVALID_ADDRESS) {
     addr_t bufaddr = process_sp->AllocateMemory(
         32, ePermissionsReadable | ePermissionsWritable, error);
     if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS) {
       LLDB_LOGF(log, "Failed to allocate memory for return buffer for get "

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

AppleGetThreadItemInfoHandler::GetThreadItemInfo(Thread &thread,
   //                                             uint64_t page_to_free_size)
 
   // Where the return_buffer argument points to a 24 byte region of memory
   // already allocated by lldb in the inferior process.
 
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
   Value return_buffer_ptr_value;
-  return_buffer_ptr_value.SetValueType(Value::eValueTypeScalar);
+  return_buffer_ptr_value.SetValueType(Value::ValueType::Scalar);
   return_buffer_ptr_value.SetCompilerType(clang_void_ptr_type);
 
   CompilerType clang_int_type = clang_ast_context->GetBasicType(eBasicTypeInt);
   Value debug_value;
-  debug_value.SetValueType(Value::eValueTypeScalar);
+  debug_value.SetValueType(Value::ValueType::Scalar);
   debug_value.SetCompilerType(clang_int_type);
 
   CompilerType clang_uint64_type =
       clang_ast_context->GetBasicType(eBasicTypeUnsignedLongLong);
   Value thread_id_value;
-  thread_id_value.SetValueType(Value::eValueTypeScalar);
+  thread_id_value.SetValueType(Value::ValueType::Scalar);
   thread_id_value.SetCompilerType(clang_uint64_type);
 
   Value page_to_free_value;
-  page_to_free_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_value.SetValueType(Value::ValueType::Scalar);
   page_to_free_value.SetCompilerType(clang_void_ptr_type);
 
   Value page_to_free_size_value;
-  page_to_free_size_value.SetValueType(Value::eValueTypeScalar);
+  page_to_free_size_value.SetValueType(Value::ValueType::Scalar);
   page_to_free_size_value.SetCompilerType(clang_uint64_type);
 
   std::lock_guard<std::mutex> guard(m_get_thread_item_info_retbuffer_mutex);
   if (m_get_thread_item_info_return_buffer_addr == LLDB_INVALID_ADDRESS) {
     addr_t bufaddr = process_sp->AllocateMemory(
         32, ePermissionsReadable | ePermissionsWritable, error);
     if (!error.Success() || bufaddr == LLDB_INVALID_ADDRESS) {
       LLDB_LOGF(log, "Failed to allocate memory for return buffer for get "

lldb/source/Target/ABI.cpp

ExpressionVariableSP expr_variable_sp(
             return_valobj_sp));
 
     assert(expr_variable_sp);
 
     // Set flags and live data as appropriate
 
     const Value &result_value = live_valobj_sp->GetValue();
 
     switch (result_value.GetValueType()) {
-    case Value::eValueTypeHostAddress:
-    case Value::eValueTypeFileAddress:
-      // we don't do anything with these for now
+    case Value::ValueType::Invalid:
+      return {};
+    case Value::ValueType::HostAddress:
+    case Value::ValueType::FileAddress:
+      // we odon't do anything with these for now
       break;
-    case Value::eValueTypeScalar:
+    case Value::ValueType::Scalar:
       expr_variable_sp->m_flags |=
           ExpressionVariable::EVIsFreezeDried;
       expr_variable_sp->m_flags |=
           ExpressionVariable::EVIsLLDBAllocated;
       expr_variable_sp->m_flags |=
           ExpressionVariable::EVNeedsAllocation;
       break;
-    case Value::eValueTypeLoadAddress:
+    case Value::ValueType::LoadAddress:
       expr_variable_sp->m_live_sp = live_valobj_sp;
       expr_variable_sp->m_flags |=
           ExpressionVariable::EVIsProgramReference;
       break;
     }
 
     return_valobj_sp = expr_variable_sp->GetValueObject();
   }

lldb/source/Target/RegisterContextUnwind.cpp

if (unwindplan_regloc.IsDWARFExpression() ||
     DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
                             unwindplan_regloc.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
     DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr);
     dwarfexpr.SetRegisterKind(unwindplan_registerkind);
     Value cfa_val = Scalar(m_cfa);
-    cfa_val.SetValueType(Value::eValueTypeLoadAddress);
+    cfa_val.SetValueType(Value::ValueType::LoadAddress);
     Value result;
     Status error;
     if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result,
                            &error)) {
       addr_t val;
       val = result.GetScalar().ULongLong();
       if (unwindplan_regloc.IsDWARFExpression()) {
         regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;

lldb/source/Target/ThreadPlanTracer.cpp

void ThreadPlanAssemblyTracer::Log() {
   TypeFromUser intptr_type = GetIntPointerType();
 
   if (abi && intptr_type.IsValid()) {
     ValueList value_list;
     const int num_args = 1;
 
     for (int arg_index = 0; arg_index < num_args; ++arg_index) {
       Value value;
-      value.SetValueType(Value::eValueTypeScalar);
+      value.SetValueType(Value::ValueType::Scalar);
       value.SetCompilerType(intptr_type);
       value_list.PushValue(value);
     }
 
     if (abi->GetArgumentValues(GetThread(), value_list)) {
       for (int arg_index = 0; arg_index < num_args; ++arg_index) {
         stream->Printf(
             "\n\targ[%d]=%llx", arg_index,

lldb/unittests/Expression/DWARFExpressionTest.cpp

static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr,
   if (!DWARFExpression::Evaluate(
           /*exe_ctx*/ nullptr, /*reg_ctx*/ nullptr, module_sp, extractor, unit,
           lldb::eRegisterKindLLDB,
           /*initial_value_ptr*/ nullptr,
           /*object_address_ptr*/ nullptr, result, &status))
     return status.ToError();
 
   switch (result.GetValueType()) {
-  case Value::eValueTypeScalar:
+  case Value::ValueType::Scalar:
     return result.GetScalar();
-  case Value::eValueTypeHostAddress: {
+  case Value::ValueType::HostAddress: {
     // Convert small buffers to scalars to simplify the tests.
     DataBufferHeap &buf = result.GetBuffer();
     if (buf.GetByteSize() <= 8) {
       uint64_t val = 0;
       memcpy(&val, buf.GetBytes(), buf.GetByteSize());
       return Scalar(llvm::APInt(buf.GetByteSize()*8, val, false));
     }
   }