*** 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, 410 insertions, 552 deletions

diff --git a/lldb/source/Symbol/Block.cpp b/lldb/source/Symbol/Block.cpp
index 9d50c5c..6c4c28d 100644
--- a/lldb/source/Symbol/Block.cpp
+++ b/lldb/source/Symbol/Block.cpp
@@ -20,628 +20,486 @@
 using namespace lldb;
 using namespace lldb_private;
 
-Block::Block(lldb::user_id_t uid) :
-    UserID(uid),
-    m_parent_scope (nullptr),
-    m_children (),
-    m_ranges (),
-    m_inlineInfoSP (),
-    m_variable_list_sp (),
-    m_parsed_block_info (false),
-    m_parsed_block_variables (false),
-    m_parsed_child_blocks (false)
-{
-}
-
-Block::~Block ()
-{
-}
-
-void
-Block::GetDescription(Stream *s, Function *function, lldb::DescriptionLevel level, Target *target) const
-{
-    *s << "id = " << ((const UserID&)*this);
-
-    size_t num_ranges = m_ranges.GetSize();
-    if (num_ranges > 0)
-    {
-        
-        addr_t base_addr = LLDB_INVALID_ADDRESS;
-        if (target)
-            base_addr = function->GetAddressRange().GetBaseAddress().GetLoadAddress(target);
-        if (base_addr == LLDB_INVALID_ADDRESS)
-            base_addr = function->GetAddressRange().GetBaseAddress().GetFileAddress();
-
-        s->Printf(", range%s = ", num_ranges > 1 ? "s" : "");
-        for (size_t i=0; i<num_ranges; ++i)
-        {
-            const Range &range = m_ranges.GetEntryRef(i);
-            s->AddressRange(base_addr + range.GetRangeBase(), base_addr + range.GetRangeEnd(), 4);
-        }
-    }
-
-    if (m_inlineInfoSP.get() != nullptr)
-    {
-        bool show_fullpaths = (level == eDescriptionLevelVerbose);
-        m_inlineInfoSP->Dump(s, show_fullpaths);
+Block::Block(lldb::user_id_t uid)
+    : UserID(uid), m_parent_scope(nullptr), m_children(), m_ranges(),
+      m_inlineInfoSP(), m_variable_list_sp(), m_parsed_block_info(false),
+      m_parsed_block_variables(false), m_parsed_child_blocks(false) {}
+
+Block::~Block() {}
+
+void Block::GetDescription(Stream *s, Function *function,
+                           lldb::DescriptionLevel level, Target *target) const {
+  *s << "id = " << ((const UserID &)*this);
+
+  size_t num_ranges = m_ranges.GetSize();
+  if (num_ranges > 0) {
+
+    addr_t base_addr = LLDB_INVALID_ADDRESS;
+    if (target)
+      base_addr =
+          function->GetAddressRange().GetBaseAddress().GetLoadAddress(target);
+    if (base_addr == LLDB_INVALID_ADDRESS)
+      base_addr = function->GetAddressRange().GetBaseAddress().GetFileAddress();
+
+    s->Printf(", range%s = ", num_ranges > 1 ? "s" : "");
+    for (size_t i = 0; i < num_ranges; ++i) {
+      const Range &range = m_ranges.GetEntryRef(i);
+      s->AddressRange(base_addr + range.GetRangeBase(),
+                      base_addr + range.GetRangeEnd(), 4);
     }
-}
-
-void
-Block::Dump(Stream *s, addr_t base_addr, int32_t depth, bool show_context) const
-{
-    if (depth < 0)
-    {
-        Block *parent = GetParent();
-        if (parent)
-        {
-            // We have a depth that is less than zero, print our parent blocks
-            // first
-            parent->Dump(s, base_addr, depth + 1, show_context);
-        }
+  }
+
+  if (m_inlineInfoSP.get() != nullptr) {
+    bool show_fullpaths = (level == eDescriptionLevelVerbose);
+    m_inlineInfoSP->Dump(s, show_fullpaths);
+  }
+}
+
+void Block::Dump(Stream *s, addr_t base_addr, int32_t depth,
+                 bool show_context) const {
+  if (depth < 0) {
+    Block *parent = GetParent();
+    if (parent) {
+      // We have a depth that is less than zero, print our parent blocks
+      // first
+      parent->Dump(s, base_addr, depth + 1, show_context);
     }
+  }
+
+  s->Printf("%p: ", static_cast<const void *>(this));
+  s->Indent();
+  *s << "Block" << static_cast<const UserID &>(*this);
+  const Block *parent_block = GetParent();
+  if (parent_block) {
+    s->Printf(", parent = {0x%8.8" PRIx64 "}", parent_block->GetID());
+  }
+  if (m_inlineInfoSP.get() != nullptr) {
+    bool show_fullpaths = false;
+    m_inlineInfoSP->Dump(s, show_fullpaths);
+  }
+
+  if (!m_ranges.IsEmpty()) {
+    *s << ", ranges =";
 
-    s->Printf("%p: ", static_cast<const void*>(this));
-    s->Indent();
-    *s << "Block" << static_cast<const UserID&>(*this);
-    const Block* parent_block = GetParent();
-    if (parent_block)
-    {
-        s->Printf(", parent = {0x%8.8" PRIx64 "}", parent_block->GetID());
-    }
-    if (m_inlineInfoSP.get() != nullptr)
-    {
-        bool show_fullpaths = false;
-        m_inlineInfoSP->Dump(s, show_fullpaths);
-    }
-
-    if (!m_ranges.IsEmpty())
-    {
-        *s << ", ranges =";
-
-        size_t num_ranges = m_ranges.GetSize();
-        for (size_t i=0; i<num_ranges; ++i)
-        {
-            const Range &range = m_ranges.GetEntryRef(i);
-            if (parent_block != nullptr && parent_block->Contains(range) == false)
-                *s << '!';
-            else
-                *s << ' ';
-            s->AddressRange(base_addr + range.GetRangeBase(), base_addr + range.GetRangeEnd(), 4);
-        }
+    size_t num_ranges = m_ranges.GetSize();
+    for (size_t i = 0; i < num_ranges; ++i) {
+      const Range &range = m_ranges.GetEntryRef(i);
+      if (parent_block != nullptr && parent_block->Contains(range) == false)
+        *s << '!';
+      else
+        *s << ' ';
+      s->AddressRange(base_addr + range.GetRangeBase(),
+                      base_addr + range.GetRangeEnd(), 4);
     }
-    s->EOL();
+  }
+  s->EOL();
 
-    if (depth > 0)
-    {
-        s->IndentMore();
+  if (depth > 0) {
+    s->IndentMore();
 
-        if (m_variable_list_sp.get())
-        {
-            m_variable_list_sp->Dump(s, show_context);
-        }
-
-        collection::const_iterator pos, end = m_children.end();
-        for (pos = m_children.begin(); pos != end; ++pos)
-            (*pos)->Dump(s, base_addr, depth - 1, show_context);
-
-        s->IndentLess();
+    if (m_variable_list_sp.get()) {
+      m_variable_list_sp->Dump(s, show_context);
     }
 
-}
-
-
-Block *
-Block::FindBlockByID (user_id_t block_id)
-{
-    if (block_id == GetID())
-        return this;
-
-    Block *matching_block = nullptr;
     collection::const_iterator pos, end = m_children.end();
     for (pos = m_children.begin(); pos != end; ++pos)
-    {
-        matching_block = (*pos)->FindBlockByID (block_id);
-        if (matching_block)
-            break;
-    }
-    return matching_block;
-}
-
-void
-Block::CalculateSymbolContext (SymbolContext* sc)
-{
-    if (m_parent_scope)
-        m_parent_scope->CalculateSymbolContext(sc);
-    sc->block = this;
-}
+      (*pos)->Dump(s, base_addr, depth - 1, show_context);
 
-lldb::ModuleSP
-Block::CalculateSymbolContextModule ()
-{
-    if (m_parent_scope)
-        return m_parent_scope->CalculateSymbolContextModule ();
-    return lldb::ModuleSP();
+    s->IndentLess();
+  }
 }
 
-CompileUnit *
-Block::CalculateSymbolContextCompileUnit ()
-{
-    if (m_parent_scope)
-        return m_parent_scope->CalculateSymbolContextCompileUnit ();
-    return nullptr;
-}
+Block *Block::FindBlockByID(user_id_t block_id) {
+  if (block_id == GetID())
+    return this;
 
-Function *
-Block::CalculateSymbolContextFunction ()
-{
-    if (m_parent_scope)
-        return m_parent_scope->CalculateSymbolContextFunction ();
-    return nullptr;
+  Block *matching_block = nullptr;
+  collection::const_iterator pos, end = m_children.end();
+  for (pos = m_children.begin(); pos != end; ++pos) {
+    matching_block = (*pos)->FindBlockByID(block_id);
+    if (matching_block)
+      break;
+  }
+  return matching_block;
 }
 
-Block *
-Block::CalculateSymbolContextBlock ()
-{
-    return this;
+void Block::CalculateSymbolContext(SymbolContext *sc) {
+  if (m_parent_scope)
+    m_parent_scope->CalculateSymbolContext(sc);
+  sc->block = this;
 }
 
-void
-Block::DumpSymbolContext(Stream *s)
-{
-    Function *function = CalculateSymbolContextFunction();
-    if (function)
-        function->DumpSymbolContext(s);
-    s->Printf(", Block{0x%8.8" PRIx64 "}", GetID());
-}
-
-void
-Block::DumpAddressRanges (Stream *s, lldb::addr_t base_addr)
-{
-    if (!m_ranges.IsEmpty())
-    {
-        size_t num_ranges = m_ranges.GetSize();
-        for (size_t i=0; i<num_ranges; ++i)
-        {
-            const Range &range = m_ranges.GetEntryRef(i);
-            s->AddressRange(base_addr + range.GetRangeBase(), base_addr + range.GetRangeEnd(), 4);
-        }
-    }
+lldb::ModuleSP Block::CalculateSymbolContextModule() {
+  if (m_parent_scope)
+    return m_parent_scope->CalculateSymbolContextModule();
+  return lldb::ModuleSP();
 }
 
-bool
-Block::Contains (addr_t range_offset) const
-{
-    return m_ranges.FindEntryThatContains(range_offset) != nullptr;
-}
-
-bool
-Block::Contains (const Block *block) const
-{
-    if (this == block)
-        return false; // This block doesn't contain itself...
-    
-    // Walk the parent chain for "block" and see if any if them match this block
-    const Block *block_parent;
-    for (block_parent = block->GetParent();
-         block_parent != nullptr;
-         block_parent = block_parent->GetParent())
-    {
-        if (this == block_parent)
-            return true; // One of the parents of "block" is this object!
-    }
-    return false;
+CompileUnit *Block::CalculateSymbolContextCompileUnit() {
+  if (m_parent_scope)
+    return m_parent_scope->CalculateSymbolContextCompileUnit();
+  return nullptr;
 }
 
-bool
-Block::Contains (const Range& range) const
-{
-    return m_ranges.FindEntryThatContains (range) != nullptr;
+Function *Block::CalculateSymbolContextFunction() {
+  if (m_parent_scope)
+    return m_parent_scope->CalculateSymbolContextFunction();
+  return nullptr;
 }
 
-Block *
-Block::GetParent () const
-{
-    if (m_parent_scope)
-        return m_parent_scope->CalculateSymbolContextBlock();
-    return nullptr;
-}
+Block *Block::CalculateSymbolContextBlock() { return this; }
 
-Block *
-Block::GetContainingInlinedBlock ()
-{
-    if (GetInlinedFunctionInfo())
-        return this;
-    return GetInlinedParent ();
+void Block::DumpSymbolContext(Stream *s) {
+  Function *function = CalculateSymbolContextFunction();
+  if (function)
+    function->DumpSymbolContext(s);
+  s->Printf(", Block{0x%8.8" PRIx64 "}", GetID());
 }
 
-Block *
-Block::GetInlinedParent ()
-{
-    Block *parent_block = GetParent ();
-    if (parent_block)
-    {
-        if (parent_block->GetInlinedFunctionInfo())
-            return parent_block;
-        else
-            return parent_block->GetInlinedParent();
+void Block::DumpAddressRanges(Stream *s, lldb::addr_t base_addr) {
+  if (!m_ranges.IsEmpty()) {
+    size_t num_ranges = m_ranges.GetSize();
+    for (size_t i = 0; i < num_ranges; ++i) {
+      const Range &range = m_ranges.GetEntryRef(i);
+      s->AddressRange(base_addr + range.GetRangeBase(),
+                      base_addr + range.GetRangeEnd(), 4);
     }
-    return nullptr;
+  }
 }
 
-
-bool
-Block::GetRangeContainingOffset (const addr_t offset, Range &range)
-{
-    const Range *range_ptr = m_ranges.FindEntryThatContains (offset);
-    if (range_ptr)
-    {
-        range = *range_ptr;
-        return true;
-    }
-    range.Clear();
-    return false;
+bool Block::Contains(addr_t range_offset) const {
+  return m_ranges.FindEntryThatContains(range_offset) != nullptr;
 }
 
+bool Block::Contains(const Block *block) const {
+  if (this == block)
+    return false; // This block doesn't contain itself...
 
-bool
-Block::GetRangeContainingAddress (const Address& addr, AddressRange &range)
-{
-    Function *function = CalculateSymbolContextFunction();
-    if (function)
-    {
-        const AddressRange &func_range = function->GetAddressRange();
-        if (addr.GetSection() == func_range.GetBaseAddress().GetSection())
-        {
-            const addr_t addr_offset = addr.GetOffset();
-            const addr_t func_offset = func_range.GetBaseAddress().GetOffset();
-            if (addr_offset >= func_offset && addr_offset < func_offset + func_range.GetByteSize())
-            {
-                addr_t offset = addr_offset - func_offset;
-                
-                const Range *range_ptr = m_ranges.FindEntryThatContains (offset);
-
-                if (range_ptr)
-                {
-                    range.GetBaseAddress() = func_range.GetBaseAddress();
-                    range.GetBaseAddress().SetOffset(func_offset + range_ptr->GetRangeBase());
-                    range.SetByteSize(range_ptr->GetByteSize());
-                    return true;
-                }
-            }
-        }
-    }
-    range.Clear();
-    return false;
+  // Walk the parent chain for "block" and see if any if them match this block
+  const Block *block_parent;
+  for (block_parent = block->GetParent(); block_parent != nullptr;
+       block_parent = block_parent->GetParent()) {
+    if (this == block_parent)
+      return true; // One of the parents of "block" is this object!
+  }
+  return false;
 }
 
-bool
-Block::GetRangeContainingLoadAddress (lldb::addr_t load_addr, Target &target, AddressRange &range)
-{
-    Address load_address;
-    load_address.SetLoadAddress(load_addr, &target);
-    AddressRange containing_range;
-    return GetRangeContainingAddress(load_address, containing_range);
+bool Block::Contains(const Range &range) const {
+  return m_ranges.FindEntryThatContains(range) != nullptr;
 }
 
+Block *Block::GetParent() const {
+  if (m_parent_scope)
+    return m_parent_scope->CalculateSymbolContextBlock();
+  return nullptr;
+}
 
-uint32_t
-Block::GetRangeIndexContainingAddress (const Address& addr)
-{
-    Function *function = CalculateSymbolContextFunction();
-    if (function)
-    {
-        const AddressRange &func_range = function->GetAddressRange();
-        if (addr.GetSection() == func_range.GetBaseAddress().GetSection())
-        {
-            const addr_t addr_offset = addr.GetOffset();
-            const addr_t func_offset = func_range.GetBaseAddress().GetOffset();
-            if (addr_offset >= func_offset && addr_offset < func_offset + func_range.GetByteSize())
-            {
-                addr_t offset = addr_offset - func_offset;
-                return m_ranges.FindEntryIndexThatContains (offset);
-            }
+Block *Block::GetContainingInlinedBlock() {
+  if (GetInlinedFunctionInfo())
+    return this;
+  return GetInlinedParent();
+}
+
+Block *Block::GetInlinedParent() {
+  Block *parent_block = GetParent();
+  if (parent_block) {
+    if (parent_block->GetInlinedFunctionInfo())
+      return parent_block;
+    else
+      return parent_block->GetInlinedParent();
+  }
+  return nullptr;
+}
+
+bool Block::GetRangeContainingOffset(const addr_t offset, Range &range) {
+  const Range *range_ptr = m_ranges.FindEntryThatContains(offset);
+  if (range_ptr) {
+    range = *range_ptr;
+    return true;
+  }
+  range.Clear();
+  return false;
+}
+
+bool Block::GetRangeContainingAddress(const Address &addr,
+                                      AddressRange &range) {
+  Function *function = CalculateSymbolContextFunction();
+  if (function) {
+    const AddressRange &func_range = function->GetAddressRange();
+    if (addr.GetSection() == func_range.GetBaseAddress().GetSection()) {
+      const addr_t addr_offset = addr.GetOffset();
+      const addr_t func_offset = func_range.GetBaseAddress().GetOffset();
+      if (addr_offset >= func_offset &&
+          addr_offset < func_offset + func_range.GetByteSize()) {
+        addr_t offset = addr_offset - func_offset;
+
+        const Range *range_ptr = m_ranges.FindEntryThatContains(offset);
+
+        if (range_ptr) {
+          range.GetBaseAddress() = func_range.GetBaseAddress();
+          range.GetBaseAddress().SetOffset(func_offset +
+                                           range_ptr->GetRangeBase());
+          range.SetByteSize(range_ptr->GetByteSize());
+          return true;
         }
+      }
     }
-    return UINT32_MAX;
-}
-
-bool
-Block::GetRangeAtIndex (uint32_t range_idx, AddressRange &range)
-{
-    if (range_idx < m_ranges.GetSize())
-    {
-        Function *function = CalculateSymbolContextFunction();
-        if (function)
-        {
-            const Range &vm_range = m_ranges.GetEntryRef(range_idx);
-            range.GetBaseAddress() = function->GetAddressRange().GetBaseAddress();
-            range.GetBaseAddress().Slide(vm_range.GetRangeBase ());
-            range.SetByteSize (vm_range.GetByteSize());
-            return true;
-        }
+  }
+  range.Clear();
+  return false;
+}
+
+bool Block::GetRangeContainingLoadAddress(lldb::addr_t load_addr,
+                                          Target &target, AddressRange &range) {
+  Address load_address;
+  load_address.SetLoadAddress(load_addr, &target);
+  AddressRange containing_range;
+  return GetRangeContainingAddress(load_address, containing_range);
+}
+
+uint32_t Block::GetRangeIndexContainingAddress(const Address &addr) {
+  Function *function = CalculateSymbolContextFunction();
+  if (function) {
+    const AddressRange &func_range = function->GetAddressRange();
+    if (addr.GetSection() == func_range.GetBaseAddress().GetSection()) {
+      const addr_t addr_offset = addr.GetOffset();
+      const addr_t func_offset = func_range.GetBaseAddress().GetOffset();
+      if (addr_offset >= func_offset &&
+          addr_offset < func_offset + func_range.GetByteSize()) {
+        addr_t offset = addr_offset - func_offset;
+        return m_ranges.FindEntryIndexThatContains(offset);
+      }
     }
-    return false;
+  }
+  return UINT32_MAX;
 }
 
-bool
-Block::GetStartAddress (Address &addr)
-{
-    if (m_ranges.IsEmpty())
-        return false;
-
+bool Block::GetRangeAtIndex(uint32_t range_idx, AddressRange &range) {
+  if (range_idx < m_ranges.GetSize()) {
     Function *function = CalculateSymbolContextFunction();
-    if (function)
-    {
-        addr = function->GetAddressRange().GetBaseAddress();
-        addr.Slide(m_ranges.GetEntryRef(0).GetRangeBase ());
-        return true;
+    if (function) {
+      const Range &vm_range = m_ranges.GetEntryRef(range_idx);
+      range.GetBaseAddress() = function->GetAddressRange().GetBaseAddress();
+      range.GetBaseAddress().Slide(vm_range.GetRangeBase());
+      range.SetByteSize(vm_range.GetByteSize());
+      return true;
     }
-    return false;
+  }
+  return false;
 }
 
-void
-Block::FinalizeRanges ()
-{
-    m_ranges.Sort();
-    m_ranges.CombineConsecutiveRanges ();
-}
-
-void
-Block::AddRange (const Range& range)
-{
-    Block *parent_block = GetParent ();
-    if (parent_block && !parent_block->Contains(range))
-    {
-        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
-        if (log)
-        {
-            ModuleSP module_sp (m_parent_scope->CalculateSymbolContextModule());
-            Function *function = m_parent_scope->CalculateSymbolContextFunction();
-            const addr_t function_file_addr = function->GetAddressRange().GetBaseAddress().GetFileAddress();
-            const addr_t block_start_addr = function_file_addr + range.GetRangeBase ();
-            const addr_t block_end_addr = function_file_addr + range.GetRangeEnd ();
-            Type *func_type = function->GetType();
-            
-            const Declaration &func_decl = func_type->GetDeclaration();
-            if (func_decl.GetLine())
-            {
-                log->Printf ("warning: %s:%u block {0x%8.8" PRIx64 "} has range[%u] [0x%" PRIx64 " - 0x%" PRIx64 ") which is not contained in parent block {0x%8.8" PRIx64 "} in function {0x%8.8" PRIx64 "} from %s",
-                             func_decl.GetFile().GetPath().c_str(),
-                             func_decl.GetLine(),
-                             GetID(),
-                             (uint32_t)m_ranges.GetSize(),
-                             block_start_addr,
-                             block_end_addr,
-                             parent_block->GetID(),
-                             function->GetID(),
-                             module_sp->GetFileSpec().GetPath().c_str());
-            }
-            else
-            {
-                log->Printf ("warning: block {0x%8.8" PRIx64 "} has range[%u] [0x%" PRIx64 " - 0x%" PRIx64 ") which is not contained in parent block {0x%8.8" PRIx64 "} in function {0x%8.8" PRIx64 "} from %s",
-                             GetID(),
-                             (uint32_t)m_ranges.GetSize(),
-                             block_start_addr,
-                             block_end_addr,
-                             parent_block->GetID(),
-                             function->GetID(),
-                             module_sp->GetFileSpec().GetPath().c_str());
-            }
-        }
-        parent_block->AddRange (range);
+bool Block::GetStartAddress(Address &addr) {
+  if (m_ranges.IsEmpty())
+    return false;
+
+  Function *function = CalculateSymbolContextFunction();
+  if (function) {
+    addr = function->GetAddressRange().GetBaseAddress();
+    addr.Slide(m_ranges.GetEntryRef(0).GetRangeBase());
+    return true;
+  }
+  return false;
+}
+
+void Block::FinalizeRanges() {
+  m_ranges.Sort();
+  m_ranges.CombineConsecutiveRanges();
+}
+
+void Block::AddRange(const Range &range) {
+  Block *parent_block = GetParent();
+  if (parent_block && !parent_block->Contains(range)) {
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS));
+    if (log) {
+      ModuleSP module_sp(m_parent_scope->CalculateSymbolContextModule());
+      Function *function = m_parent_scope->CalculateSymbolContextFunction();
+      const addr_t function_file_addr =
+          function->GetAddressRange().GetBaseAddress().GetFileAddress();
+      const addr_t block_start_addr = function_file_addr + range.GetRangeBase();
+      const addr_t block_end_addr = function_file_addr + range.GetRangeEnd();
+      Type *func_type = function->GetType();
+
+      const Declaration &func_decl = func_type->GetDeclaration();
+      if (func_decl.GetLine()) {
+        log->Printf("warning: %s:%u block {0x%8.8" PRIx64
+                    "} has range[%u] [0x%" PRIx64 " - 0x%" PRIx64
+                    ") which is not contained in parent block {0x%8.8" PRIx64
+                    "} in function {0x%8.8" PRIx64 "} from %s",
+                    func_decl.GetFile().GetPath().c_str(), func_decl.GetLine(),
+                    GetID(), (uint32_t)m_ranges.GetSize(), block_start_addr,
+                    block_end_addr, parent_block->GetID(), function->GetID(),
+                    module_sp->GetFileSpec().GetPath().c_str());
+      } else {
+        log->Printf("warning: block {0x%8.8" PRIx64
+                    "} has range[%u] [0x%" PRIx64 " - 0x%" PRIx64
+                    ") which is not contained in parent block {0x%8.8" PRIx64
+                    "} in function {0x%8.8" PRIx64 "} from %s",
+                    GetID(), (uint32_t)m_ranges.GetSize(), block_start_addr,
+                    block_end_addr, parent_block->GetID(), function->GetID(),
+                    module_sp->GetFileSpec().GetPath().c_str());
+      }
     }
-    m_ranges.Append(range);
+    parent_block->AddRange(range);
+  }
+  m_ranges.Append(range);
 }
 
 // Return the current number of bytes that this object occupies in memory
-size_t
-Block::MemorySize() const
-{
-    size_t mem_size = sizeof(Block) + m_ranges.GetSize() * sizeof(Range);
-    if (m_inlineInfoSP.get())
-        mem_size += m_inlineInfoSP->MemorySize();
-    if (m_variable_list_sp.get())
-        mem_size += m_variable_list_sp->MemorySize();
-    return mem_size;
-
-}
-
-void
-Block::AddChild(const BlockSP &child_block_sp)
-{
-    if (child_block_sp)
-    {
-        child_block_sp->SetParentScope (this);
-        m_children.push_back (child_block_sp);
+size_t Block::MemorySize() const {
+  size_t mem_size = sizeof(Block) + m_ranges.GetSize() * sizeof(Range);
+  if (m_inlineInfoSP.get())
+    mem_size += m_inlineInfoSP->MemorySize();
+  if (m_variable_list_sp.get())
+    mem_size += m_variable_list_sp->MemorySize();
+  return mem_size;
+}
+
+void Block::AddChild(const BlockSP &child_block_sp) {
+  if (child_block_sp) {
+    child_block_sp->SetParentScope(this);
+    m_children.push_back(child_block_sp);
+  }
+}
+
+void Block::SetInlinedFunctionInfo(const char *name, const char *mangled,
+                                   const Declaration *decl_ptr,
+                                   const Declaration *call_decl_ptr) {
+  m_inlineInfoSP.reset(
+      new InlineFunctionInfo(name, mangled, decl_ptr, call_decl_ptr));
+}
+
+VariableListSP Block::GetBlockVariableList(bool can_create) {
+  if (m_parsed_block_variables == false) {
+    if (m_variable_list_sp.get() == nullptr && can_create) {
+      m_parsed_block_variables = true;
+      SymbolContext sc;
+      CalculateSymbolContext(&sc);
+      assert(sc.module_sp);
+      sc.module_sp->GetSymbolVendor()->ParseVariablesForContext(sc);
     }
+  }
+  return m_variable_list_sp;
 }
 
-void
-Block::SetInlinedFunctionInfo(const char *name, const char *mangled, const Declaration *decl_ptr, const Declaration *call_decl_ptr)
-{
-    m_inlineInfoSP.reset(new InlineFunctionInfo(name, mangled, decl_ptr, call_decl_ptr));
-}
+uint32_t
+Block::AppendBlockVariables(bool can_create, bool get_child_block_variables,
+                            bool stop_if_child_block_is_inlined_function,
+                            const std::function<bool(Variable *)> &filter,
+                            VariableList *variable_list) {
+  uint32_t num_variables_added = 0;
+  VariableList *block_var_list = GetBlockVariableList(can_create).get();
+  if (block_var_list) {
+    for (size_t i = 0; i < block_var_list->GetSize(); ++i) {
+      VariableSP variable = block_var_list->GetVariableAtIndex(i);
+      if (filter(variable.get())) {
+        num_variables_added++;
+        variable_list->AddVariable(variable);
+      }
+    }
+  }
 
+  if (get_child_block_variables) {
+    collection::const_iterator pos, end = m_children.end();
+    for (pos = m_children.begin(); pos != end; ++pos) {
+      Block *child_block = pos->get();
+      if (stop_if_child_block_is_inlined_function == false ||
+          child_block->GetInlinedFunctionInfo() == nullptr) {
+        num_variables_added += child_block->AppendBlockVariables(
+            can_create, get_child_block_variables,
+            stop_if_child_block_is_inlined_function, filter, variable_list);
+      }
+    }
+  }
+  return num_variables_added;
+}
+
+uint32_t Block::AppendVariables(bool can_create, bool get_parent_variables,
+                                bool stop_if_block_is_inlined_function,
+                                const std::function<bool(Variable *)> &filter,
+                                VariableList *variable_list) {
+  uint32_t num_variables_added = 0;
+  VariableListSP variable_list_sp(GetBlockVariableList(can_create));
+
+  bool is_inlined_function = GetInlinedFunctionInfo() != nullptr;
+  if (variable_list_sp) {
+    for (size_t i = 0; i < variable_list_sp->GetSize(); ++i) {
+      VariableSP variable = variable_list_sp->GetVariableAtIndex(i);
+      if (filter(variable.get())) {
+        num_variables_added++;
+        variable_list->AddVariable(variable);
+      }
+    }
+  }
 
+  if (get_parent_variables) {
+    if (stop_if_block_is_inlined_function && is_inlined_function)
+      return num_variables_added;
 
-VariableListSP
-Block::GetBlockVariableList (bool can_create)
-{
-    if (m_parsed_block_variables == false)
-    {
-        if (m_variable_list_sp.get() == nullptr && can_create)
-        {
-            m_parsed_block_variables = true;
-            SymbolContext sc;
-            CalculateSymbolContext(&sc);
-            assert(sc.module_sp);
-            sc.module_sp->GetSymbolVendor()->ParseVariablesForContext(sc);
-        }
-    }
-    return m_variable_list_sp;
+    Block *parent_block = GetParent();
+    if (parent_block)
+      num_variables_added += parent_block->AppendVariables(
+          can_create, get_parent_variables, stop_if_block_is_inlined_function,
+          filter, variable_list);
+  }
+  return num_variables_added;
 }
 
-uint32_t
-Block::AppendBlockVariables (bool can_create,
-                             bool get_child_block_variables,
-                             bool stop_if_child_block_is_inlined_function,
-                             const std::function<bool(Variable*)>& filter,
-                             VariableList *variable_list)
-{
-    uint32_t num_variables_added = 0;
-    VariableList *block_var_list = GetBlockVariableList (can_create).get();
-    if (block_var_list)
-    {
-        for (size_t i = 0; i < block_var_list->GetSize(); ++i)
-        {
-            VariableSP variable = block_var_list->GetVariableAtIndex(i);
-            if (filter(variable.get()))
-            {
-                num_variables_added++;
-                variable_list->AddVariable(variable);
-            }
-        }
-    }
+CompilerDeclContext Block::GetDeclContext() {
+  ModuleSP module_sp = CalculateSymbolContextModule();
 
-    if (get_child_block_variables)
-    {
-        collection::const_iterator pos, end = m_children.end();
-        for (pos = m_children.begin(); pos != end; ++pos)
-        {
-            Block *child_block = pos->get();
-            if (stop_if_child_block_is_inlined_function == false || 
-                child_block->GetInlinedFunctionInfo() == nullptr)
-            {
-                num_variables_added += child_block->AppendBlockVariables (can_create,
-                                                                          get_child_block_variables,
-                                                                          stop_if_child_block_is_inlined_function,
-                                                                          filter,
-                                                                          variable_list);
-            }
-        }
-    }
-    return num_variables_added;
-}
+  if (module_sp) {
+    SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
 
-uint32_t
-Block::AppendVariables 
-(
-    bool can_create, 
-    bool get_parent_variables, 
-    bool stop_if_block_is_inlined_function,
-    const std::function<bool(Variable*)>& filter,
-    VariableList *variable_list
-)
-{
-    uint32_t num_variables_added = 0;
-    VariableListSP variable_list_sp(GetBlockVariableList(can_create));
-
-    bool is_inlined_function = GetInlinedFunctionInfo() != nullptr;
-    if (variable_list_sp)
-    {
-        for (size_t i = 0; i < variable_list_sp->GetSize(); ++i)
-        {
-            VariableSP variable = variable_list_sp->GetVariableAtIndex(i);
-            if (filter(variable.get()))
-            {
-                num_variables_added++;
-                variable_list->AddVariable(variable);
-            }
-        }
-    }
+    if (sym_vendor) {
+      SymbolFile *sym_file = sym_vendor->GetSymbolFile();
 
-    if (get_parent_variables)
-    {
-        if (stop_if_block_is_inlined_function && is_inlined_function)
-            return num_variables_added;
-            
-        Block* parent_block = GetParent();
-        if (parent_block)
-            num_variables_added += parent_block->AppendVariables(can_create,
-                                                                 get_parent_variables,
-                                                                 stop_if_block_is_inlined_function,
-                                                                 filter,
-                                                                 variable_list);
-    }
-    return num_variables_added;
-}
-
-CompilerDeclContext
-Block::GetDeclContext()
-{
-    ModuleSP module_sp = CalculateSymbolContextModule ();
-
-    if (module_sp)
-    {
-        SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
-    
-        if (sym_vendor)
-        {
-            SymbolFile *sym_file = sym_vendor->GetSymbolFile();
-    
-            if (sym_file)
-                return sym_file->GetDeclContextForUID (GetID());
-        }
-    }
-    return CompilerDeclContext();
-}
-
-void
-Block::SetBlockInfoHasBeenParsed (bool b, bool set_children)
-{
-    m_parsed_block_info = b;
-    if (set_children)
-    {
-        m_parsed_child_blocks = true;
-        collection::const_iterator pos, end = m_children.end();
-        for (pos = m_children.begin(); pos != end; ++pos)
-            (*pos)->SetBlockInfoHasBeenParsed (b, true);
+      if (sym_file)
+        return sym_file->GetDeclContextForUID(GetID());
     }
+  }
+  return CompilerDeclContext();
 }
 
-void
-Block::SetDidParseVariables (bool b, bool set_children)
-{
-    m_parsed_block_variables = b;
-    if (set_children)
-    {
-        collection::const_iterator pos, end = m_children.end();
-        for (pos = m_children.begin(); pos != end; ++pos)
-            (*pos)->SetDidParseVariables (b, true);
-    }
+void Block::SetBlockInfoHasBeenParsed(bool b, bool set_children) {
+  m_parsed_block_info = b;
+  if (set_children) {
+    m_parsed_child_blocks = true;
+    collection::const_iterator pos, end = m_children.end();
+    for (pos = m_children.begin(); pos != end; ++pos)
+      (*pos)->SetBlockInfoHasBeenParsed(b, true);
+  }
 }
 
+void Block::SetDidParseVariables(bool b, bool set_children) {
+  m_parsed_block_variables = b;
+  if (set_children) {
+    collection::const_iterator pos, end = m_children.end();
+    for (pos = m_children.begin(); pos != end; ++pos)
+      (*pos)->SetDidParseVariables(b, true);
+  }
+}
 
-Block *
-Block::GetSibling() const
-{
-    if (m_parent_scope)
-    {
-        Block *parent_block = GetParent();
-        if (parent_block)
-            return parent_block->GetSiblingForChild (this);
-    }
-    return nullptr;
+Block *Block::GetSibling() const {
+  if (m_parent_scope) {
+    Block *parent_block = GetParent();
+    if (parent_block)
+      return parent_block->GetSiblingForChild(this);
+  }
+  return nullptr;
 }
 // A parent of child blocks can be asked to find a sibling block given
 // one of its child blocks
-Block *
-Block::GetSiblingForChild (const Block *child_block) const
-{
-    if (!m_children.empty())
-    {
-        collection::const_iterator pos, end = m_children.end();
-        for (pos = m_children.begin(); pos != end; ++pos)
-        {
-            if (pos->get() == child_block)
-            {
-                if (++pos != end)
-                    return pos->get();
-                break;
-            }
-        }
+Block *Block::GetSiblingForChild(const Block *child_block) const {
+  if (!m_children.empty()) {
+    collection::const_iterator pos, end = m_children.end();
+    for (pos = m_children.begin(); pos != end; ++pos) {
+      if (pos->get() == child_block) {
+        if (++pos != end)
+          return pos->get();
+        break;
+      }
     }
-    return nullptr;
+  }
+  return nullptr;
 }
-