Add a new way to bind a format to a type: by enum type

The "type format add" command gets a new flag --type (-t). If you pass -t <sometype>, upon fetching the value for an object of your type,
LLDB will display it as-if it was of enumeration type <sometype>
This is useful in cases of non-contiguous enums where there are empty gaps of unspecified values, and as such one cannot type their variables as the enum type,
but users would still like to see them as-if they were of the enum type (e.g. DWARF field types with their user-reserved ranges)

The SB API has also been improved to handle both types of formats, and a test case is added

llvm-svn: 198105

1 files changed, 47 insertions, 9 deletions

diff --git a/lldb/source/API/SBTypeFormat.cpp b/lldb/source/API/SBTypeFormat.cpp
index 34ab404a206..d3ec9bc00bd 100644
--- a/lldb/source/API/SBTypeFormat.cpp
+++ b/lldb/source/API/SBTypeFormat.cpp
@@ -25,7 +25,13 @@ m_opaque_sp()
 
 SBTypeFormat::SBTypeFormat (lldb::Format format,
                             uint32_t options)
-: m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl(format,options)))
+: m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_Format(format,options)))
+{
+}
+
+SBTypeFormat::SBTypeFormat (const char* type,
+                            uint32_t options)
+: m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType(ConstString(type ? type : ""),options)))
 {
 }
 
@@ -47,11 +53,19 @@ SBTypeFormat::IsValid() const
 lldb::Format
 SBTypeFormat::GetFormat ()
 {
-    if (IsValid())
-        return m_opaque_sp->GetFormat();
+    if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
+        return ((TypeFormatImpl_Format*)m_opaque_sp.get())->GetFormat();
     return lldb::eFormatInvalid;
 }
 
+const char*
+SBTypeFormat::GetTypeName ()
+{
+    if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)
+        return ((TypeFormatImpl_EnumType*)m_opaque_sp.get())->GetTypeName().AsCString("");
+    return "";
+}
+
 uint32_t
 SBTypeFormat::GetOptions()
 {
@@ -63,14 +77,21 @@ SBTypeFormat::GetOptions()
 void
 SBTypeFormat::SetFormat (lldb::Format fmt)
 {
-    if (CopyOnWrite_Impl())
-        m_opaque_sp->SetFormat(fmt);
+    if (CopyOnWrite_Impl(Type::eTypeFormat))
+        ((TypeFormatImpl_Format*)m_opaque_sp.get())->SetFormat(fmt);
+}
+
+void
+SBTypeFormat::SetTypeName (const char* type)
+{
+    if (CopyOnWrite_Impl(Type::eTypeEnum))
+        ((TypeFormatImpl_EnumType*)m_opaque_sp.get())->SetTypeName(ConstString(type ? type : ""));
 }
 
 void
 SBTypeFormat::SetOptions (uint32_t value)
 {
-    if (CopyOnWrite_Impl())
+    if (CopyOnWrite_Impl(Type::eTypeKeepSame))
         m_opaque_sp->SetOptions(value);
 }
 
@@ -143,13 +164,30 @@ SBTypeFormat::SBTypeFormat (const lldb::TypeFormatImplSP &typeformat_impl_sp) :
 }
 
 bool
-SBTypeFormat::CopyOnWrite_Impl()
+SBTypeFormat::CopyOnWrite_Impl(Type type)
 {
     if (!IsValid())
         return false;
-    if (m_opaque_sp.unique())
+    
+    if (m_opaque_sp.unique() &&
+        ((type == Type::eTypeKeepSame) ||
+         (type == Type::eTypeFormat && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat) ||
+         (type == Type::eTypeEnum && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum))
+        )
         return true;
 
-    SetSP(TypeFormatImplSP(new TypeFormatImpl(GetFormat(),GetOptions())));
+    if (type == Type::eTypeKeepSame)
+    {
+        if (m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
+            type = Type::eTypeFormat;
+        else
+            type = Type::eTypeEnum;
+    }
+    
+    if (type == Type::eTypeFormat)
+        SetSP(TypeFormatImplSP(new TypeFormatImpl_Format(GetFormat(),GetOptions())));
+    else
+        SetSP(TypeFormatImplSP(new TypeFormatImpl_EnumType(ConstString(GetTypeName()),GetOptions())));
+    
     return true;
 }