*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 206 insertions, 292 deletions

diff --git a/lldb/source/Core/ValueObjectConstResult.cpp b/lldb/source/Core/ValueObjectConstResult.cpp
index 441cee540f7..f78574ef7ee 100644
--- a/lldb/source/Core/ValueObjectConstResult.cpp
+++ b/lldb/source/Core/ValueObjectConstResult.cpp
@@ -9,10 +9,10 @@
 
 #include "lldb/Core/ValueObjectConstResult.h"
 
-#include "lldb/Core/ValueObjectChild.h"
-#include "lldb/Core/ValueObjectConstResultChild.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Core/ValueObjectChild.h"
+#include "lldb/Core/ValueObjectConstResultChild.h"
 #include "lldb/Core/ValueObjectDynamicValue.h"
 #include "lldb/Core/ValueObjectList.h"
 
@@ -29,356 +29,270 @@
 using namespace lldb;
 using namespace lldb_private;
 
-ValueObjectSP
-ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
-                                ByteOrder byte_order,
-                                uint32_t addr_byte_size,
-                                lldb::addr_t address)
-{
-    return (new ValueObjectConstResult (exe_scope,
-                                        byte_order,
-                                        addr_byte_size,
-                                        address))->GetSP();
+ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
+                                             ByteOrder byte_order,
+                                             uint32_t addr_byte_size,
+                                             lldb::addr_t address) {
+  return (new ValueObjectConstResult(exe_scope, byte_order, addr_byte_size,
+                                     address))
+      ->GetSP();
 }
 
-ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                ByteOrder byte_order,
-                                                uint32_t addr_byte_size,
-                                                lldb::addr_t address) :
-    ValueObject (exe_scope),
-    m_type_name (),
-    m_byte_size (0),
-    m_impl(this, address)
-{
-    SetIsConstant ();
-    SetValueIsValid(true);
-    m_data.SetByteOrder(byte_order);
-    m_data.SetAddressByteSize(addr_byte_size);
-    SetAddressTypeOfChildren(eAddressTypeLoad);
+ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
+                                               ByteOrder byte_order,
+                                               uint32_t addr_byte_size,
+                                               lldb::addr_t address)
+    : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
+      m_impl(this, address) {
+  SetIsConstant();
+  SetValueIsValid(true);
+  m_data.SetByteOrder(byte_order);
+  m_data.SetAddressByteSize(addr_byte_size);
+  SetAddressTypeOfChildren(eAddressTypeLoad);
 }
 
-ValueObjectSP
-ValueObjectConstResult::Create
-(
-    ExecutionContextScope *exe_scope,
-    const CompilerType &compiler_type,
-    const ConstString &name,
-    const DataExtractor &data,
-    lldb::addr_t address
-)
-{
-    return (new ValueObjectConstResult (exe_scope,
-                                        compiler_type,
-                                        name,
-                                        data,
-                                        address))->GetSP();
+ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
+                                             const CompilerType &compiler_type,
+                                             const ConstString &name,
+                                             const DataExtractor &data,
+                                             lldb::addr_t address) {
+  return (new ValueObjectConstResult(exe_scope, compiler_type, name, data,
+                                     address))
+      ->GetSP();
 }
 
-ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                const CompilerType &compiler_type,
-                                                const ConstString &name,
-                                                const DataExtractor &data,
-                                                lldb::addr_t address) :
-    ValueObject (exe_scope),
-    m_type_name (),
-    m_byte_size (0),
-    m_impl(this, address)
-{
-    m_data = data;
-    
-    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.SetCompilerType(compiler_type);
-    m_name = name;
-    SetIsConstant ();
-    SetValueIsValid(true);
-    SetAddressTypeOfChildren(eAddressTypeLoad);
+ValueObjectConstResult::ValueObjectConstResult(
+    ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
+    const ConstString &name, const DataExtractor &data, lldb::addr_t address)
+    : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
+      m_impl(this, address) {
+  m_data = data;
+
+  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.SetCompilerType(compiler_type);
+  m_name = name;
+  SetIsConstant();
+  SetValueIsValid(true);
+  SetAddressTypeOfChildren(eAddressTypeLoad);
 }
 
-ValueObjectSP
-ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
-                                const CompilerType &compiler_type,
-                                const ConstString &name,
-                                const lldb::DataBufferSP &data_sp,
-                                lldb::ByteOrder data_byte_order,
-                                uint32_t data_addr_size,
-                                lldb::addr_t address)
-{
-    return (new ValueObjectConstResult (exe_scope,
-                                        compiler_type,
-                                        name,
-                                        data_sp,
-                                        data_byte_order,
-                                        data_addr_size,
-                                        address))->GetSP();
+ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
+                                             const CompilerType &compiler_type,
+                                             const ConstString &name,
+                                             const lldb::DataBufferSP &data_sp,
+                                             lldb::ByteOrder data_byte_order,
+                                             uint32_t data_addr_size,
+                                             lldb::addr_t address) {
+  return (new ValueObjectConstResult(exe_scope, compiler_type, name, data_sp,
+                                     data_byte_order, data_addr_size, address))
+      ->GetSP();
 }
 
-ValueObjectSP
-ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
-                                Value &value,
-                                const ConstString &name,
-                                Module *module)
-{
-    return (new ValueObjectConstResult (exe_scope, value, name, module))->GetSP();
+ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
+                                             Value &value,
+                                             const ConstString &name,
+                                             Module *module) {
+  return (new ValueObjectConstResult(exe_scope, value, name, module))->GetSP();
 }
 
-ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                const CompilerType &compiler_type,
-                                                const ConstString &name,
-                                                const lldb::DataBufferSP &data_sp,
-                                                lldb::ByteOrder data_byte_order, 
-                                                uint32_t data_addr_size,
-                                                lldb::addr_t address) :
-    ValueObject (exe_scope),
-    m_type_name (),
-    m_byte_size (0),
-    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.SetContext(Value::eContextTypeClangType, compiler_type);
-    m_value.SetCompilerType (compiler_type);
-    m_name = name;
-    SetIsConstant ();
-    SetValueIsValid(true);
-    SetAddressTypeOfChildren(eAddressTypeLoad);
+ValueObjectConstResult::ValueObjectConstResult(
+    ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
+    const ConstString &name, const lldb::DataBufferSP &data_sp,
+    lldb::ByteOrder data_byte_order, uint32_t data_addr_size,
+    lldb::addr_t address)
+    : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
+      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.SetContext(Value::eContextTypeClangType, compiler_type);
+  m_value.SetCompilerType(compiler_type);
+  m_name = name;
+  SetIsConstant();
+  SetValueIsValid(true);
+  SetAddressTypeOfChildren(eAddressTypeLoad);
 }
 
-ValueObjectSP
-ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
-                                const CompilerType &compiler_type,
-                                const ConstString &name,
-                                lldb::addr_t address,
-                                AddressType address_type,
-                                uint32_t addr_byte_size)
-{
-    return (new ValueObjectConstResult (exe_scope,
-                                        compiler_type,
-                                        name,
-                                        address,
-                                        address_type,
-                                        addr_byte_size))->GetSP();
+ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
+                                             const CompilerType &compiler_type,
+                                             const ConstString &name,
+                                             lldb::addr_t address,
+                                             AddressType address_type,
+                                             uint32_t addr_byte_size) {
+  return (new ValueObjectConstResult(exe_scope, compiler_type, name, address,
+                                     address_type, addr_byte_size))
+      ->GetSP();
 }
 
-ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                const CompilerType &compiler_type,
-                                                const ConstString &name,
-                                                lldb::addr_t address,
-                                                AddressType address_type,
-                                                uint32_t addr_byte_size) :
-    ValueObject (exe_scope),
-    m_type_name (),
-    m_byte_size (0),
-    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); 
-    switch (address_type)
-    {
-    case eAddressTypeInvalid:   m_value.SetValueType(Value::eValueTypeScalar);      break;
-    case eAddressTypeFile:      m_value.SetValueType(Value::eValueTypeFileAddress); break;
-    case eAddressTypeLoad:      m_value.SetValueType(Value::eValueTypeLoadAddress); break;    
-    case eAddressTypeHost:      m_value.SetValueType(Value::eValueTypeHostAddress); break;
-    }
-//    m_value.SetContext(Value::eContextTypeClangType, compiler_type);
-    m_value.SetCompilerType (compiler_type);
-    m_name = name;
-    SetIsConstant ();
-    SetValueIsValid(true);
-    SetAddressTypeOfChildren(eAddressTypeLoad);
+ValueObjectConstResult::ValueObjectConstResult(
+    ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
+    const ConstString &name, lldb::addr_t address, AddressType address_type,
+    uint32_t addr_byte_size)
+    : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
+      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);
+  switch (address_type) {
+  case eAddressTypeInvalid:
+    m_value.SetValueType(Value::eValueTypeScalar);
+    break;
+  case eAddressTypeFile:
+    m_value.SetValueType(Value::eValueTypeFileAddress);
+    break;
+  case eAddressTypeLoad:
+    m_value.SetValueType(Value::eValueTypeLoadAddress);
+    break;
+  case eAddressTypeHost:
+    m_value.SetValueType(Value::eValueTypeHostAddress);
+    break;
+  }
+  //    m_value.SetContext(Value::eContextTypeClangType, compiler_type);
+  m_value.SetCompilerType(compiler_type);
+  m_name = name;
+  SetIsConstant();
+  SetValueIsValid(true);
+  SetAddressTypeOfChildren(eAddressTypeLoad);
 }
 
-ValueObjectSP
-ValueObjectConstResult::Create
-(
-    ExecutionContextScope *exe_scope,
-    const Error& error
-)
-{
-    return (new ValueObjectConstResult (exe_scope,
-                                        error))->GetSP();
+ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
+                                             const Error &error) {
+  return (new ValueObjectConstResult(exe_scope, error))->GetSP();
 }
 
-ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                const Error& error) :
-    ValueObject (exe_scope),
-    m_type_name (),
-    m_byte_size (0),
-    m_impl(this)
-{
-    m_error = error;
-    SetIsConstant ();
+ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
+                                               const Error &error)
+    : ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
+  m_error = error;
+  SetIsConstant();
 }
 
-ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
-                                                const Value &value,
-                                                const ConstString &name,
-                                                Module *module) :
-    ValueObject (exe_scope),
-    m_type_name (),
-    m_byte_size (0),
-    m_impl(this)
-{
-    m_value = value;
-    m_name = name;
-    ExecutionContext exe_ctx;
-    exe_scope->CalculateExecutionContext(exe_ctx);
-    m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, module);
+ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
+                                               const Value &value,
+                                               const ConstString &name,
+                                               Module *module)
+    : ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
+  m_value = value;
+  m_name = name;
+  ExecutionContext exe_ctx;
+  exe_scope->CalculateExecutionContext(exe_ctx);
+  m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, module);
 }
 
-ValueObjectConstResult::~ValueObjectConstResult()
-{
-}
+ValueObjectConstResult::~ValueObjectConstResult() {}
 
-CompilerType
-ValueObjectConstResult::GetCompilerTypeImpl()
-{
-    return m_value.GetCompilerType();
+CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
+  return m_value.GetCompilerType();
 }
 
-lldb::ValueType
-ValueObjectConstResult::GetValueType() const
-{
-    return eValueTypeConstResult;
+lldb::ValueType ValueObjectConstResult::GetValueType() const {
+  return eValueTypeConstResult;
 }
 
-uint64_t
-ValueObjectConstResult::GetByteSize()
-{
-    ExecutionContext exe_ctx(GetExecutionContextRef());
+uint64_t ValueObjectConstResult::GetByteSize() {
+  ExecutionContext exe_ctx(GetExecutionContextRef());
 
-    if (m_byte_size == 0)
-        SetByteSize(GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()));
-    return m_byte_size;
+  if (m_byte_size == 0)
+    SetByteSize(
+        GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()));
+  return m_byte_size;
 }
 
-void
-ValueObjectConstResult::SetByteSize (size_t size)
-{
-    m_byte_size = size;
-}
+void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
 
-size_t
-ValueObjectConstResult::CalculateNumChildren(uint32_t max)
-{
-    auto children_count = GetCompilerType().GetNumChildren (true);
-    return children_count <= max ? children_count : max;
+size_t ValueObjectConstResult::CalculateNumChildren(uint32_t max) {
+  auto children_count = GetCompilerType().GetNumChildren(true);
+  return children_count <= max ? children_count : max;
 }
 
-ConstString
-ValueObjectConstResult::GetTypeName()
-{
-    if (m_type_name.IsEmpty())
-        m_type_name = GetCompilerType().GetConstTypeName ();
-    return m_type_name;
+ConstString ValueObjectConstResult::GetTypeName() {
+  if (m_type_name.IsEmpty())
+    m_type_name = GetCompilerType().GetConstTypeName();
+  return m_type_name;
 }
 
-ConstString
-ValueObjectConstResult::GetDisplayTypeName()
-{
-    return GetCompilerType().GetDisplayTypeName();
+ConstString ValueObjectConstResult::GetDisplayTypeName() {
+  return GetCompilerType().GetDisplayTypeName();
 }
 
-bool
-ValueObjectConstResult::UpdateValue ()
-{
-    // Const value is always valid
-    SetValueIsValid (true);
-    return true;
+bool ValueObjectConstResult::UpdateValue() {
+  // Const value is always valid
+  SetValueIsValid(true);
+  return true;
 }
 
-
-bool
-ValueObjectConstResult::IsInScope ()
-{
-    // A const result value is always in scope since it serializes all 
-    // information needed to contain the constant value.
-    return true;
+bool ValueObjectConstResult::IsInScope() {
+  // A const result value is always in scope since it serializes all
+  // information needed to contain the constant value.
+  return true;
 }
 
-lldb::ValueObjectSP
-ValueObjectConstResult::Dereference (Error &error)
-{
-    return m_impl.Dereference(error);
+lldb::ValueObjectSP ValueObjectConstResult::Dereference(Error &error) {
+  return m_impl.Dereference(error);
 }
 
-lldb::ValueObjectSP
-ValueObjectConstResult::GetSyntheticChildAtOffset(uint32_t offset,
-                                                  const CompilerType& type,
-                                                  bool can_create,
-                                                  ConstString name_const_str)
-{
-    return m_impl.GetSyntheticChildAtOffset(offset, type, can_create, name_const_str);
+lldb::ValueObjectSP ValueObjectConstResult::GetSyntheticChildAtOffset(
+    uint32_t offset, const CompilerType &type, bool can_create,
+    ConstString name_const_str) {
+  return m_impl.GetSyntheticChildAtOffset(offset, type, can_create,
+                                          name_const_str);
 }
 
-lldb::ValueObjectSP
-ValueObjectConstResult::AddressOf (Error &error)
-{
-    return m_impl.AddressOf(error);
+lldb::ValueObjectSP ValueObjectConstResult::AddressOf(Error &error) {
+  return m_impl.AddressOf(error);
 }
 
-lldb::addr_t
-ValueObjectConstResult::GetAddressOf (bool scalar_is_load_address,
-                                      AddressType *address_type)
-{
-    return m_impl.GetAddressOf(scalar_is_load_address, address_type);
+lldb::addr_t ValueObjectConstResult::GetAddressOf(bool scalar_is_load_address,
+                                                  AddressType *address_type) {
+  return m_impl.GetAddressOf(scalar_is_load_address, address_type);
 }
 
-ValueObject *
-ValueObjectConstResult::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index)
-{
-    return m_impl.CreateChildAtIndex(idx, synthetic_array_member, synthetic_index);
+ValueObject *ValueObjectConstResult::CreateChildAtIndex(
+    size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
+  return m_impl.CreateChildAtIndex(idx, synthetic_array_member,
+                                   synthetic_index);
 }
 
-size_t
-ValueObjectConstResult::GetPointeeData (DataExtractor& data,
-                                        uint32_t item_idx,
-                                        uint32_t item_count)
-{
-    return m_impl.GetPointeeData(data, item_idx, item_count);
+size_t ValueObjectConstResult::GetPointeeData(DataExtractor &data,
+                                              uint32_t item_idx,
+                                              uint32_t item_count) {
+  return m_impl.GetPointeeData(data, item_idx, item_count);
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResult::GetDynamicValue (lldb::DynamicValueType use_dynamic)
-{
-    // Always recalculate dynamic values for const results as the memory that
-    // they might point to might have changed at any time.
-    if (use_dynamic != eNoDynamicValues)
-    {
-        if (!IsDynamic())
-        {
-            ExecutionContext exe_ctx (GetExecutionContextRef());
-            Process *process = exe_ctx.GetProcessPtr();
-            if (process && process->IsPossibleDynamicValue(*this))
-                m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic);
-        }
-        if (m_dynamic_value)
-            return m_dynamic_value->GetSP();
+ValueObjectConstResult::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
+  // Always recalculate dynamic values for const results as the memory that
+  // they might point to might have changed at any time.
+  if (use_dynamic != eNoDynamicValues) {
+    if (!IsDynamic()) {
+      ExecutionContext exe_ctx(GetExecutionContextRef());
+      Process *process = exe_ctx.GetProcessPtr();
+      if (process && process->IsPossibleDynamicValue(*this))
+        m_dynamic_value = new ValueObjectDynamicValue(*this, use_dynamic);
     }
-    return ValueObjectSP();
+    if (m_dynamic_value)
+      return m_dynamic_value->GetSP();
+  }
+  return ValueObjectSP();
 }
 
 lldb::ValueObjectSP
-ValueObjectConstResult::Cast (const CompilerType &compiler_type)
-{
-    return m_impl.Cast(compiler_type);
+ValueObjectConstResult::Cast(const CompilerType &compiler_type) {
+  return m_impl.Cast(compiler_type);
 }
 
-lldb::LanguageType
-ValueObjectConstResult::GetPreferredDisplayLanguage ()
-{
-    if (m_preferred_display_language != lldb::eLanguageTypeUnknown)
-        return m_preferred_display_language;
-    return GetCompilerTypeImpl().GetMinimumLanguage();
+lldb::LanguageType ValueObjectConstResult::GetPreferredDisplayLanguage() {
+  if (m_preferred_display_language != lldb::eLanguageTypeUnknown)
+    return m_preferred_display_language;
+  return GetCompilerTypeImpl().GetMinimumLanguage();
 }