Initial checkin of lldb code from internal Apple repo.

llvm-svn: 105619

1 files changed, 331 insertions, 0 deletions

diff --git a/lldb/source/Core/ValueObjectRegister.cpp b/lldb/source/Core/ValueObjectRegister.cpp
new file mode 100644
index 00000000000..aae818eadd6
--- /dev/null
+++ b/lldb/source/Core/ValueObjectRegister.cpp
@@ -0,0 +1,331 @@
+//===-- ValueObjectRegister.cpp ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include "lldb/Core/ValueObjectRegister.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/Module.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeList.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+#pragma mark ValueObjectRegisterContext
+
+ValueObjectRegisterContext::ValueObjectRegisterContext (RegisterContext *reg_ctx) :
+    ValueObject (),
+    m_reg_ctx (reg_ctx)
+{
+    assert (reg_ctx);
+    m_name.SetCString("Registers");
+    SetValueIsValid (true);
+}
+
+ValueObjectRegisterContext::~ValueObjectRegisterContext()
+{
+}
+
+void *
+ValueObjectRegisterContext::GetOpaqueClangQualType ()
+{
+    return NULL;
+}
+
+ConstString
+ValueObjectRegisterContext::GetTypeName()
+{
+    ConstString empty_type_name;
+    return empty_type_name;
+}
+
+uint32_t
+ValueObjectRegisterContext::CalculateNumChildren()
+{
+    return m_reg_ctx->GetRegisterSetCount();
+}
+
+clang::ASTContext *
+ValueObjectRegisterContext::GetClangAST ()
+{
+    return NULL;
+}
+
+size_t
+ValueObjectRegisterContext::GetByteSize()
+{
+    return 0;
+}
+
+void
+ValueObjectRegisterContext::UpdateValue (ExecutionContextScope *exe_scope)
+{
+    m_error.Clear();
+    StackFrame *frame = exe_scope->CalculateStackFrame();
+    if (frame)
+        m_reg_ctx = frame->GetRegisterContext();
+    else
+        m_reg_ctx = NULL;
+
+    SetValueIsValid (m_reg_ctx != NULL);
+}
+
+ValueObjectSP
+ValueObjectRegisterContext::CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index)
+{
+    ValueObjectSP valobj_sp;
+
+    const uint32_t num_children = GetNumChildren();
+    if (idx < num_children)
+        valobj_sp.reset (new ValueObjectRegisterSet(m_reg_ctx, idx));
+    return valobj_sp;
+}
+
+
+#pragma mark -
+#pragma mark ValueObjectRegisterSet
+
+ValueObjectRegisterSet::ValueObjectRegisterSet (RegisterContext *reg_ctx, uint32_t reg_set_idx) :
+    ValueObject (),
+    m_reg_ctx (reg_ctx),
+    m_reg_set (NULL),
+    m_reg_set_idx (reg_set_idx)
+{
+    assert (reg_ctx);
+    m_reg_set = reg_ctx->GetRegisterSet(m_reg_set_idx);
+    if (m_reg_set)
+    {
+        m_name.SetCString (m_reg_set->name);
+    }
+}
+
+ValueObjectRegisterSet::~ValueObjectRegisterSet()
+{
+}
+
+void *
+ValueObjectRegisterSet::GetOpaqueClangQualType ()
+{
+    return NULL;
+}
+
+ConstString
+ValueObjectRegisterSet::GetTypeName()
+{
+    return ConstString();
+}
+
+uint32_t
+ValueObjectRegisterSet::CalculateNumChildren()
+{
+    const RegisterSet *reg_set = m_reg_ctx->GetRegisterSet(m_reg_set_idx);
+    if (reg_set)
+        return reg_set->num_registers;
+    return 0;
+}
+
+clang::ASTContext *
+ValueObjectRegisterSet::GetClangAST ()
+{
+    return NULL;
+}
+
+size_t
+ValueObjectRegisterSet::GetByteSize()
+{
+    return 0;
+}
+
+void
+ValueObjectRegisterSet::UpdateValue (ExecutionContextScope *exe_scope)
+{
+    m_error.Clear();
+    SetValueDidChange (false);
+    StackFrame *frame = exe_scope->CalculateStackFrame();
+    if (frame == NULL)
+        m_reg_ctx = NULL;
+    else
+    {
+        m_reg_ctx = frame->GetRegisterContext ();
+        if (m_reg_ctx)
+        {
+            const RegisterSet *reg_set = m_reg_ctx->GetRegisterSet (m_reg_set_idx);
+            if (reg_set == NULL)
+                m_reg_ctx = NULL;
+            else if (m_reg_set != reg_set)
+            {
+                SetValueDidChange (true);
+                m_name.SetCString(reg_set->name);
+            }
+        }
+    }
+    if (m_reg_ctx)
+    {
+        SetValueIsValid (true);
+    }
+    else
+    {
+        SetValueIsValid (false);
+        m_children.clear();
+    }
+}
+
+
+ValueObjectSP
+ValueObjectRegisterSet::CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index)
+{
+    ValueObjectSP valobj_sp;
+    if (m_reg_ctx && m_reg_set)
+    {
+        const uint32_t num_children = GetNumChildren();
+        if (idx < num_children)
+            valobj_sp.reset (new ValueObjectRegister(m_reg_ctx, m_reg_set->registers[idx]));
+    }
+    return valobj_sp;
+}
+
+
+#pragma mark -
+#pragma mark ValueObjectRegister
+
+ValueObjectRegister::ValueObjectRegister (RegisterContext *reg_ctx, uint32_t reg_num) :
+    ValueObject (),
+    m_reg_ctx (reg_ctx),
+    m_reg_info (NULL),
+    m_reg_num (reg_num),
+    m_type_name (),
+    m_clang_type (NULL)
+{
+    assert (reg_ctx);
+    m_reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
+    if (m_reg_info)
+    {
+        if (m_reg_info->name)
+            m_name.SetCString(m_reg_info->name);
+        else if (m_reg_info->alt_name)
+            m_name.SetCString(m_reg_info->alt_name);
+    }
+}
+
+ValueObjectRegister::~ValueObjectRegister()
+{
+}
+
+void *
+ValueObjectRegister::GetOpaqueClangQualType ()
+{
+    if (m_clang_type == NULL && m_reg_info)
+    {
+        Process *process = m_reg_ctx->CalculateProcess ();
+        if (process)
+        {
+            Module *exe_module = process->GetTarget().GetExecutableModule ().get();
+            if (exe_module)
+            {
+                TypeList *type_list = exe_module->GetTypeList();
+                if (type_list)
+                    m_clang_type = type_list->GetClangASTContext().GetBuiltinTypeForEncodingAndBitSize (m_reg_info->encoding, m_reg_info->byte_size * 8);
+            }
+        }
+    }
+    return m_clang_type;
+}
+
+ConstString
+ValueObjectRegister::GetTypeName()
+{
+    if (m_type_name.IsEmpty())
+        m_type_name = Type::GetClangTypeName (GetOpaqueClangQualType());
+    return m_type_name;
+}
+
+uint32_t
+ValueObjectRegister::CalculateNumChildren()
+{
+    return 0;
+}
+
+clang::ASTContext *
+ValueObjectRegister::GetClangAST ()
+{
+    Process *process = m_reg_ctx->CalculateProcess ();
+    if (process)
+    {
+        Module *exe_module = process->GetTarget().GetExecutableModule ().get();
+        if (exe_module)
+        {
+            TypeList *type_list = exe_module->GetTypeList();
+            if (type_list)
+                return type_list->GetClangASTContext().getASTContext();
+        }
+    }
+    return NULL;
+}
+
+size_t
+ValueObjectRegister::GetByteSize()
+{
+    return m_reg_info->byte_size;
+}
+
+void
+ValueObjectRegister::UpdateValue (ExecutionContextScope *exe_scope)
+{
+    m_error.Clear();
+    StackFrame *frame = exe_scope->CalculateStackFrame();
+    if (frame)
+    {
+        m_reg_ctx = frame->GetRegisterContext();
+        if (m_reg_ctx)
+        {
+            const RegisterInfo *reg_info = m_reg_ctx->GetRegisterInfoAtIndex(m_reg_num);
+            if (m_reg_info != reg_info)
+            {
+                m_reg_info = reg_info;
+                if (m_reg_info)
+                {
+                    if (m_reg_info->name)
+                        m_name.SetCString(m_reg_info->name);
+                    else if (m_reg_info->alt_name)
+                        m_name.SetCString(m_reg_info->alt_name);
+                }
+            }
+        }
+    }
+    else
+    {
+        m_reg_ctx = NULL;
+        m_reg_info = NULL;
+    }
+
+
+    if (m_reg_ctx && m_reg_info)
+    {
+        if (m_reg_ctx->ReadRegisterBytes (m_reg_num, m_data))
+        {
+            m_value.SetContext(Value::eContextTypeDCRegisterInfo, (void *)m_reg_info);
+            m_value.SetValueType(Value::eValueTypeHostAddress);
+            m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
+            SetValueIsValid (true);
+            return;
+        }
+    }
+    SetValueIsValid (false);
+}
+
+