*** 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, 681 insertions, 751 deletions

diff --git a/lldb/source/Expression/IRMemoryMap.cpp b/lldb/source/Expression/IRMemoryMap.cpp
index aa165722c43..008838d5aab 100644
--- a/lldb/source/Expression/IRMemoryMap.cpp
+++ b/lldb/source/Expression/IRMemoryMap.cpp
@@ -7,12 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Scalar.h"
-#include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
@@ -20,223 +20,204 @@
 
 using namespace lldb_private;
 
-IRMemoryMap::IRMemoryMap (lldb::TargetSP target_sp) :
-    m_target_wp(target_sp)
-{
-    if (target_sp)
-        m_process_wp = target_sp->GetProcessSP();
+IRMemoryMap::IRMemoryMap(lldb::TargetSP target_sp) : m_target_wp(target_sp) {
+  if (target_sp)
+    m_process_wp = target_sp->GetProcessSP();
 }
 
-IRMemoryMap::~IRMemoryMap ()
-{
-    lldb::ProcessSP process_sp = m_process_wp.lock();
+IRMemoryMap::~IRMemoryMap() {
+  lldb::ProcessSP process_sp = m_process_wp.lock();
 
-    if (process_sp)
-    {
-        AllocationMap::iterator iter;
-
-        Error err;
-
-        while ((iter = m_allocations.begin()) != m_allocations.end())
-        {
-            err.Clear();
-            if (iter->second.m_leak)
-                m_allocations.erase(iter);
-            else
-                Free(iter->first, err);
-        }
-    }
-}
+  if (process_sp) {
+    AllocationMap::iterator iter;
 
-lldb::addr_t
-IRMemoryMap::FindSpace (size_t size)
-{
-    // The FindSpace algorithm's job is to find a region of memory that the
-    // underlying process is unlikely to be using.
-    //
-    // The memory returned by this function will never be written to.  The only
-    // point is that it should not shadow process memory if possible, so that
-    // expressions processing real values from the process do not use the
-    // wrong data.
-    //
-    // If the process can in fact allocate memory (CanJIT() lets us know this)
-    // then this can be accomplished just be allocating memory in the inferior.
-    // Then no guessing is required.
+    Error err;
 
-    lldb::TargetSP target_sp = m_target_wp.lock();
-    lldb::ProcessSP process_sp = m_process_wp.lock();
-    
-    const bool process_is_alive = process_sp && process_sp->IsAlive();
+    while ((iter = m_allocations.begin()) != m_allocations.end()) {
+      err.Clear();
+      if (iter->second.m_leak)
+        m_allocations.erase(iter);
+      else
+        Free(iter->first, err);
+    }
+  }
+}
 
-    lldb::addr_t ret = LLDB_INVALID_ADDRESS;
-    if (size == 0)
-        return ret;
+lldb::addr_t IRMemoryMap::FindSpace(size_t size) {
+  // The FindSpace algorithm's job is to find a region of memory that the
+  // underlying process is unlikely to be using.
+  //
+  // The memory returned by this function will never be written to.  The only
+  // point is that it should not shadow process memory if possible, so that
+  // expressions processing real values from the process do not use the
+  // wrong data.
+  //
+  // If the process can in fact allocate memory (CanJIT() lets us know this)
+  // then this can be accomplished just be allocating memory in the inferior.
+  // Then no guessing is required.
+
+  lldb::TargetSP target_sp = m_target_wp.lock();
+  lldb::ProcessSP process_sp = m_process_wp.lock();
+
+  const bool process_is_alive = process_sp && process_sp->IsAlive();
+
+  lldb::addr_t ret = LLDB_INVALID_ADDRESS;
+  if (size == 0)
+    return ret;
 
-    if (process_is_alive && process_sp->CanJIT())
-    {
-        Error alloc_error;
+  if (process_is_alive && process_sp->CanJIT()) {
+    Error alloc_error;
 
-        ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable | lldb::ePermissionsWritable, alloc_error);
+    ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable |
+                                               lldb::ePermissionsWritable,
+                                     alloc_error);
 
-        if (!alloc_error.Success())
-            return LLDB_INVALID_ADDRESS;
-        else
-            return ret;
-    }
-    
-    // At this point we know that we need to hunt.
-    //
-    // First, go to the end of the existing allocations we've made if there are
-    // any allocations.  Otherwise start at the beginning of memory.
-
-    if (m_allocations.empty())
-    {
-        ret = 0x0;
-    }
+    if (!alloc_error.Success())
+      return LLDB_INVALID_ADDRESS;
     else
-    {
-        auto back = m_allocations.rbegin();
-        lldb::addr_t addr = back->first;
-        size_t alloc_size = back->second.m_size;
-        ret = llvm::alignTo(addr+alloc_size, 4096);
-    }
-    
-    // Now, if it's possible to use the GetMemoryRegionInfo API to detect mapped
-    // regions, walk forward through memory until a region is found that
-    // has adequate space for our allocation.
-    if (process_is_alive)
-    {
-        const uint64_t end_of_memory = process_sp->GetAddressByteSize() == 8 ?
-            0xffffffffffffffffull : 0xffffffffull;
-        
-        lldbassert(process_sp->GetAddressByteSize() == 4 || end_of_memory != 0xffffffffull);
-        
-        MemoryRegionInfo region_info;
-        Error err = process_sp->GetMemoryRegionInfo(ret, region_info);
-        if (err.Success())
-        {
-            while (true)
-            {
-                if (region_info.GetReadable() != MemoryRegionInfo::OptionalBool::eNo ||
-                    region_info.GetWritable() != MemoryRegionInfo::OptionalBool::eNo ||
-                    region_info.GetExecutable() != MemoryRegionInfo::OptionalBool::eNo)
-                {
-                    if (region_info.GetRange().GetRangeEnd() - 1 >= end_of_memory)
-                    {
-                        ret = LLDB_INVALID_ADDRESS;
-                        break;
-                    }
-                    else
-                    {
-                        ret = region_info.GetRange().GetRangeEnd();
-                    }
-                }
-                else if (ret + size < region_info.GetRange().GetRangeEnd())
-                {
-                    return ret;
-                }
-                else
-                {
-                    // ret stays the same.  We just need to walk a bit further.
-                }
-                
-                err = process_sp->GetMemoryRegionInfo(region_info.GetRange().GetRangeEnd(), region_info);
-                if (err.Fail())
-                {
-                    lldbassert(!"GetMemoryRegionInfo() succeeded, then failed");
-                    ret = LLDB_INVALID_ADDRESS;
-                    break;
-                }
-            }
+      return ret;
+  }
+
+  // At this point we know that we need to hunt.
+  //
+  // First, go to the end of the existing allocations we've made if there are
+  // any allocations.  Otherwise start at the beginning of memory.
+
+  if (m_allocations.empty()) {
+    ret = 0x0;
+  } else {
+    auto back = m_allocations.rbegin();
+    lldb::addr_t addr = back->first;
+    size_t alloc_size = back->second.m_size;
+    ret = llvm::alignTo(addr + alloc_size, 4096);
+  }
+
+  // Now, if it's possible to use the GetMemoryRegionInfo API to detect mapped
+  // regions, walk forward through memory until a region is found that
+  // has adequate space for our allocation.
+  if (process_is_alive) {
+    const uint64_t end_of_memory = process_sp->GetAddressByteSize() == 8
+                                       ? 0xffffffffffffffffull
+                                       : 0xffffffffull;
+
+    lldbassert(process_sp->GetAddressByteSize() == 4 ||
+               end_of_memory != 0xffffffffull);
+
+    MemoryRegionInfo region_info;
+    Error err = process_sp->GetMemoryRegionInfo(ret, region_info);
+    if (err.Success()) {
+      while (true) {
+        if (region_info.GetReadable() != MemoryRegionInfo::OptionalBool::eNo ||
+            region_info.GetWritable() != MemoryRegionInfo::OptionalBool::eNo ||
+            region_info.GetExecutable() !=
+                MemoryRegionInfo::OptionalBool::eNo) {
+          if (region_info.GetRange().GetRangeEnd() - 1 >= end_of_memory) {
+            ret = LLDB_INVALID_ADDRESS;
+            break;
+          } else {
+            ret = region_info.GetRange().GetRangeEnd();
+          }
+        } else if (ret + size < region_info.GetRange().GetRangeEnd()) {
+          return ret;
+        } else {
+          // ret stays the same.  We just need to walk a bit further.
         }
-    }
-    
-    // We've tried our algorithm, and it didn't work.  Now we have to reset back
-    // to the end of the allocations we've already reported, or use a 'sensible'
-    // default if this is our first allocation.
-    
-    if (m_allocations.empty())
-    {
-        uint32_t address_byte_size = GetAddressByteSize();
-        if (address_byte_size != UINT32_MAX)
-        {
-            switch (address_byte_size)
-            {
-                case 8:
-                    ret = 0xffffffff00000000ull;
-                    break;
-                case 4:
-                    ret = 0xee000000ull;
-                    break;
-                default:
-                    break;
-            }
+
+        err = process_sp->GetMemoryRegionInfo(
+            region_info.GetRange().GetRangeEnd(), region_info);
+        if (err.Fail()) {
+          lldbassert(!"GetMemoryRegionInfo() succeeded, then failed");
+          ret = LLDB_INVALID_ADDRESS;
+          break;
         }
+      }
     }
-    else
-    {
-        auto back = m_allocations.rbegin();
-        lldb::addr_t addr = back->first;
-        size_t alloc_size = back->second.m_size;
-        ret = llvm::alignTo(addr+alloc_size, 4096);
+  }
+
+  // We've tried our algorithm, and it didn't work.  Now we have to reset back
+  // to the end of the allocations we've already reported, or use a 'sensible'
+  // default if this is our first allocation.
+
+  if (m_allocations.empty()) {
+    uint32_t address_byte_size = GetAddressByteSize();
+    if (address_byte_size != UINT32_MAX) {
+      switch (address_byte_size) {
+      case 8:
+        ret = 0xffffffff00000000ull;
+        break;
+      case 4:
+        ret = 0xee000000ull;
+        break;
+      default:
+        break;
+      }
     }
+  } else {
+    auto back = m_allocations.rbegin();
+    lldb::addr_t addr = back->first;
+    size_t alloc_size = back->second.m_size;
+    ret = llvm::alignTo(addr + alloc_size, 4096);
+  }
 
-    return ret;
+  return ret;
 }
 
 IRMemoryMap::AllocationMap::iterator
-IRMemoryMap::FindAllocation (lldb::addr_t addr, size_t size)
-{
-    if (addr == LLDB_INVALID_ADDRESS)
-        return m_allocations.end();
-
-    AllocationMap::iterator iter = m_allocations.lower_bound (addr);
-
-    if (iter == m_allocations.end() ||
-        iter->first > addr)
-    {
-        if (iter == m_allocations.begin())
-            return m_allocations.end();
-        iter--;
-    }
+IRMemoryMap::FindAllocation(lldb::addr_t addr, size_t size) {
+  if (addr == LLDB_INVALID_ADDRESS)
+    return m_allocations.end();
 
-    if (iter->first <= addr && iter->first + iter->second.m_size >= addr + size)
-        return iter;
+  AllocationMap::iterator iter = m_allocations.lower_bound(addr);
 
-    return m_allocations.end();
-}
+  if (iter == m_allocations.end() || iter->first > addr) {
+    if (iter == m_allocations.begin())
+      return m_allocations.end();
+    iter--;
+  }
 
-bool
-IRMemoryMap::IntersectsAllocation (lldb::addr_t addr, size_t size) const
-{
-    if (addr == LLDB_INVALID_ADDRESS)
-        return false;
-
-    AllocationMap::const_iterator iter = m_allocations.lower_bound (addr);
-
-    // Since we only know that the returned interval begins at a location greater than or
-    // equal to where the given interval begins, it's possible that the given interval
-    // intersects either the returned interval or the previous interval.  Thus, we need to
-    // check both. Note that we only need to check these two intervals.  Since all intervals
-    // are disjoint it is not possible that an adjacent interval does not intersect, but a
-    // non-adjacent interval does intersect.
-    if (iter != m_allocations.end()) {
-        if (AllocationsIntersect(addr, size, iter->second.m_process_start, iter->second.m_size))
-            return true;
-    }
+  if (iter->first <= addr && iter->first + iter->second.m_size >= addr + size)
+    return iter;
 
-    if (iter != m_allocations.begin()) {
-        --iter;
-        if (AllocationsIntersect(addr, size, iter->second.m_process_start, iter->second.m_size))
-            return true;
-    }
+  return m_allocations.end();
+}
 
+bool IRMemoryMap::IntersectsAllocation(lldb::addr_t addr, size_t size) const {
+  if (addr == LLDB_INVALID_ADDRESS)
     return false;
+
+  AllocationMap::const_iterator iter = m_allocations.lower_bound(addr);
+
+  // Since we only know that the returned interval begins at a location greater
+  // than or
+  // equal to where the given interval begins, it's possible that the given
+  // interval
+  // intersects either the returned interval or the previous interval.  Thus, we
+  // need to
+  // check both. Note that we only need to check these two intervals.  Since all
+  // intervals
+  // are disjoint it is not possible that an adjacent interval does not
+  // intersect, but a
+  // non-adjacent interval does intersect.
+  if (iter != m_allocations.end()) {
+    if (AllocationsIntersect(addr, size, iter->second.m_process_start,
+                             iter->second.m_size))
+      return true;
+  }
+
+  if (iter != m_allocations.begin()) {
+    --iter;
+    if (AllocationsIntersect(addr, size, iter->second.m_process_start,
+                             iter->second.m_size))
+      return true;
+  }
+
+  return false;
 }
 
-bool
-IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1, lldb::addr_t addr2, size_t size2) {
-  // Given two half open intervals [A, B) and [X, Y), the only 6 permutations that satisfy
+bool IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1,
+                                       lldb::addr_t addr2, size_t size2) {
+  // Given two half open intervals [A, B) and [X, Y), the only 6 permutations
+  // that satisfy
   // A<B and X<Y are the following:
   // A B X Y
   // A X B Y  (intersects)
@@ -249,666 +230,615 @@ IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1, lldb::addr_t
   return (addr2 < (addr1 + size1)) && (addr1 < (addr2 + size2));
 }
 
-lldb::ByteOrder
-IRMemoryMap::GetByteOrder()
-{
-    lldb::ProcessSP process_sp = m_process_wp.lock();
+lldb::ByteOrder IRMemoryMap::GetByteOrder() {
+  lldb::ProcessSP process_sp = m_process_wp.lock();
 
-    if (process_sp)
-        return process_sp->GetByteOrder();
+  if (process_sp)
+    return process_sp->GetByteOrder();
 
-    lldb::TargetSP target_sp = m_target_wp.lock();
+  lldb::TargetSP target_sp = m_target_wp.lock();
 
-    if (target_sp)
-        return target_sp->GetArchitecture().GetByteOrder();
+  if (target_sp)
+    return target_sp->GetArchitecture().GetByteOrder();
 
-    return lldb::eByteOrderInvalid;
+  return lldb::eByteOrderInvalid;
 }
 
-uint32_t
-IRMemoryMap::GetAddressByteSize()
-{
-    lldb::ProcessSP process_sp = m_process_wp.lock();
+uint32_t IRMemoryMap::GetAddressByteSize() {
+  lldb::ProcessSP process_sp = m_process_wp.lock();
 
-    if (process_sp)
-        return process_sp->GetAddressByteSize();
+  if (process_sp)
+    return process_sp->GetAddressByteSize();
 
-    lldb::TargetSP target_sp = m_target_wp.lock();
+  lldb::TargetSP target_sp = m_target_wp.lock();
 
-    if (target_sp)
-        return target_sp->GetArchitecture().GetAddressByteSize();
+  if (target_sp)
+    return target_sp->GetArchitecture().GetAddressByteSize();
 
-    return UINT32_MAX;
+  return UINT32_MAX;
 }
 
-ExecutionContextScope *
-IRMemoryMap::GetBestExecutionContextScope() const
-{
-    lldb::ProcessSP process_sp = m_process_wp.lock();
+ExecutionContextScope *IRMemoryMap::GetBestExecutionContextScope() const {
+  lldb::ProcessSP process_sp = m_process_wp.lock();
 
-    if (process_sp)
-        return process_sp.get();
+  if (process_sp)
+    return process_sp.get();
 
-    lldb::TargetSP target_sp = m_target_wp.lock();
+  lldb::TargetSP target_sp = m_target_wp.lock();
 
-    if (target_sp)
-        return target_sp.get();
+  if (target_sp)
+    return target_sp.get();
 
-    return NULL;
+  return NULL;
 }
 
-IRMemoryMap::Allocation::Allocation (lldb::addr_t process_alloc,
-                                     lldb::addr_t process_start,
-                                     size_t size,
-                                     uint32_t permissions,
-                                     uint8_t alignment,
-                                     AllocationPolicy policy) :
-    m_process_alloc (process_alloc),
-    m_process_start (process_start),
-    m_size (size),
-    m_permissions (permissions),
-    m_alignment (alignment),
-    m_policy (policy),
-    m_leak (false)
-{
-    switch (policy)
-    {
-        default:
-            assert (0 && "We cannot reach this!");
-        case eAllocationPolicyHostOnly:
-            m_data.SetByteSize(size);
-            memset(m_data.GetBytes(), 0, size);
-            break;
-        case eAllocationPolicyProcessOnly:
-            break;
-        case eAllocationPolicyMirror:
-            m_data.SetByteSize(size);
-            memset(m_data.GetBytes(), 0, size);
-            break;
-    }
+IRMemoryMap::Allocation::Allocation(lldb::addr_t process_alloc,
+                                    lldb::addr_t process_start, size_t size,
+                                    uint32_t permissions, uint8_t alignment,
+                                    AllocationPolicy policy)
+    : m_process_alloc(process_alloc), m_process_start(process_start),
+      m_size(size), m_permissions(permissions), m_alignment(alignment),
+      m_policy(policy), m_leak(false) {
+  switch (policy) {
+  default:
+    assert(0 && "We cannot reach this!");
+  case eAllocationPolicyHostOnly:
+    m_data.SetByteSize(size);
+    memset(m_data.GetBytes(), 0, size);
+    break;
+  case eAllocationPolicyProcessOnly:
+    break;
+  case eAllocationPolicyMirror:
+    m_data.SetByteSize(size);
+    memset(m_data.GetBytes(), 0, size);
+    break;
+  }
 }
 
-lldb::addr_t
-IRMemoryMap::Malloc (size_t size, uint8_t alignment, uint32_t permissions, AllocationPolicy policy, bool zero_memory, Error &error)
-{
-    lldb_private::Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-    error.Clear();
-
-    lldb::ProcessSP process_sp;
-    lldb::addr_t    allocation_address  = LLDB_INVALID_ADDRESS;
-    lldb::addr_t    aligned_address     = LLDB_INVALID_ADDRESS;
-
-    size_t          alignment_mask = alignment - 1;
-    size_t          allocation_size;
-
-    if (size == 0)
-        allocation_size = alignment;
-    else
-        allocation_size = (size & alignment_mask) ? ((size + alignment) & (~alignment_mask)) : size;
-
-    switch (policy)
-    {
-    default:
+lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
+                                 uint32_t permissions, AllocationPolicy policy,
+                                 bool zero_memory, Error &error) {
+  lldb_private::Log *log(
+      lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+  error.Clear();
+
+  lldb::ProcessSP process_sp;
+  lldb::addr_t allocation_address = LLDB_INVALID_ADDRESS;
+  lldb::addr_t aligned_address = LLDB_INVALID_ADDRESS;
+
+  size_t alignment_mask = alignment - 1;
+  size_t allocation_size;
+
+  if (size == 0)
+    allocation_size = alignment;
+  else
+    allocation_size = (size & alignment_mask)
+                          ? ((size + alignment) & (~alignment_mask))
+                          : size;
+
+  switch (policy) {
+  default:
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't malloc: invalid allocation policy");
+    return LLDB_INVALID_ADDRESS;
+  case eAllocationPolicyHostOnly:
+    allocation_address = FindSpace(allocation_size);
+    if (allocation_address == LLDB_INVALID_ADDRESS) {
+      error.SetErrorToGenericError();
+      error.SetErrorString("Couldn't malloc: address space is full");
+      return LLDB_INVALID_ADDRESS;
+    }
+    break;
+  case eAllocationPolicyMirror:
+    process_sp = m_process_wp.lock();
+    if (log)
+      log->Printf("IRMemoryMap::%s process_sp=0x%" PRIx64
+                  ", process_sp->CanJIT()=%s, process_sp->IsAlive()=%s",
+                  __FUNCTION__, (lldb::addr_t)process_sp.get(),
+                  process_sp && process_sp->CanJIT() ? "true" : "false",
+                  process_sp && process_sp->IsAlive() ? "true" : "false");
+    if (process_sp && process_sp->CanJIT() && process_sp->IsAlive()) {
+      if (!zero_memory)
+        allocation_address =
+            process_sp->AllocateMemory(allocation_size, permissions, error);
+      else
+        allocation_address =
+            process_sp->CallocateMemory(allocation_size, permissions, error);
+
+      if (!error.Success())
+        return LLDB_INVALID_ADDRESS;
+    } else {
+      if (log)
+        log->Printf("IRMemoryMap::%s switching to eAllocationPolicyHostOnly "
+                    "due to failed condition (see previous expr log message)",
+                    __FUNCTION__);
+      policy = eAllocationPolicyHostOnly;
+      allocation_address = FindSpace(allocation_size);
+      if (allocation_address == LLDB_INVALID_ADDRESS) {
         error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't malloc: invalid allocation policy");
+        error.SetErrorString("Couldn't malloc: address space is full");
         return LLDB_INVALID_ADDRESS;
-    case eAllocationPolicyHostOnly:
-        allocation_address = FindSpace(allocation_size);
-        if (allocation_address == LLDB_INVALID_ADDRESS)
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorString("Couldn't malloc: address space is full");
-            return LLDB_INVALID_ADDRESS;
-        }
-        break;
-    case eAllocationPolicyMirror:
-        process_sp = m_process_wp.lock();
-        if (log)
-            log->Printf ("IRMemoryMap::%s process_sp=0x%" PRIx64 ", process_sp->CanJIT()=%s, process_sp->IsAlive()=%s", __FUNCTION__, (lldb::addr_t) process_sp.get (), process_sp && process_sp->CanJIT () ? "true" : "false", process_sp && process_sp->IsAlive () ? "true" : "false");
-        if (process_sp && process_sp->CanJIT() && process_sp->IsAlive())
-        {
-            if (!zero_memory)
-              allocation_address = process_sp->AllocateMemory(allocation_size, permissions, error);
-            else
-              allocation_address = process_sp->CallocateMemory(allocation_size, permissions, error);
-
-            if (!error.Success())
-                return LLDB_INVALID_ADDRESS;
-        }
-        else
-        {
-            if (log)
-                log->Printf ("IRMemoryMap::%s switching to eAllocationPolicyHostOnly due to failed condition (see previous expr log message)", __FUNCTION__);
-            policy = eAllocationPolicyHostOnly;
-            allocation_address = FindSpace(allocation_size);
-            if (allocation_address == LLDB_INVALID_ADDRESS)
-            {
-                error.SetErrorToGenericError();
-                error.SetErrorString("Couldn't malloc: address space is full");
-                return LLDB_INVALID_ADDRESS;
-            }
-        }
-        break;
-    case eAllocationPolicyProcessOnly:
-        process_sp = m_process_wp.lock();
-        if (process_sp)
-        {
-            if (process_sp->CanJIT() && process_sp->IsAlive())
-            {
-                if (!zero_memory)
-                  allocation_address = process_sp->AllocateMemory(allocation_size, permissions, error);
-                else
-                  allocation_address = process_sp->CallocateMemory(allocation_size, permissions, error);
-
-                if (!error.Success())
-                    return LLDB_INVALID_ADDRESS;
-            }
-            else
-            {
-                error.SetErrorToGenericError();
-                error.SetErrorString("Couldn't malloc: process doesn't support allocating memory");
-                return LLDB_INVALID_ADDRESS;
-            }
-        }
+      }
+    }
+    break;
+  case eAllocationPolicyProcessOnly:
+    process_sp = m_process_wp.lock();
+    if (process_sp) {
+      if (process_sp->CanJIT() && process_sp->IsAlive()) {
+        if (!zero_memory)
+          allocation_address =
+              process_sp->AllocateMemory(allocation_size, permissions, error);
         else
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorString("Couldn't malloc: process doesn't exist, and this memory must be in the process");
-            return LLDB_INVALID_ADDRESS;
-        }
-        break;
-    }
+          allocation_address =
+              process_sp->CallocateMemory(allocation_size, permissions, error);
 
+        if (!error.Success())
+          return LLDB_INVALID_ADDRESS;
+      } else {
+        error.SetErrorToGenericError();
+        error.SetErrorString(
+            "Couldn't malloc: process doesn't support allocating memory");
+        return LLDB_INVALID_ADDRESS;
+      }
+    } else {
+      error.SetErrorToGenericError();
+      error.SetErrorString("Couldn't malloc: process doesn't exist, and this "
+                           "memory must be in the process");
+      return LLDB_INVALID_ADDRESS;
+    }
+    break;
+  }
 
-    lldb::addr_t mask = alignment - 1;
-    aligned_address = (allocation_address + mask) & (~mask);
+  lldb::addr_t mask = alignment - 1;
+  aligned_address = (allocation_address + mask) & (~mask);
 
-    m_allocations[aligned_address] = Allocation(allocation_address,
-                                                aligned_address,
-                                                allocation_size,
-                                                permissions,
-                                                alignment,
-                                                policy);
+  m_allocations[aligned_address] =
+      Allocation(allocation_address, aligned_address, allocation_size,
+                 permissions, alignment, policy);
 
-    if (zero_memory)
-    {
-        Error write_error;
-        std::vector<uint8_t> zero_buf(size, 0);
-        WriteMemory(aligned_address, zero_buf.data(), size, write_error);
-    }
+  if (zero_memory) {
+    Error write_error;
+    std::vector<uint8_t> zero_buf(size, 0);
+    WriteMemory(aligned_address, zero_buf.data(), size, write_error);
+  }
 
-    if (log)
-    {
-        const char * policy_string;
+  if (log) {
+    const char *policy_string;
 
-        switch (policy)
-        {
-        default:
-            policy_string = "<invalid policy>";
-            break;
-        case eAllocationPolicyHostOnly:
-            policy_string = "eAllocationPolicyHostOnly";
-            break;
-        case eAllocationPolicyProcessOnly:
-            policy_string = "eAllocationPolicyProcessOnly";
-            break;
-        case eAllocationPolicyMirror:
-            policy_string = "eAllocationPolicyMirror";
-            break;
-        }
-
-        log->Printf("IRMemoryMap::Malloc (%" PRIu64 ", 0x%" PRIx64 ", 0x%" PRIx64 ", %s) -> 0x%" PRIx64,
-                    (uint64_t)allocation_size,
-                    (uint64_t)alignment,
-                    (uint64_t)permissions,
-                    policy_string,
-                    aligned_address);
+    switch (policy) {
+    default:
+      policy_string = "<invalid policy>";
+      break;
+    case eAllocationPolicyHostOnly:
+      policy_string = "eAllocationPolicyHostOnly";
+      break;
+    case eAllocationPolicyProcessOnly:
+      policy_string = "eAllocationPolicyProcessOnly";
+      break;
+    case eAllocationPolicyMirror:
+      policy_string = "eAllocationPolicyMirror";
+      break;
     }
 
-    return aligned_address;
+    log->Printf("IRMemoryMap::Malloc (%" PRIu64 ", 0x%" PRIx64 ", 0x%" PRIx64
+                ", %s) -> 0x%" PRIx64,
+                (uint64_t)allocation_size, (uint64_t)alignment,
+                (uint64_t)permissions, policy_string, aligned_address);
+  }
+
+  return aligned_address;
 }
 
-void
-IRMemoryMap::Leak (lldb::addr_t process_address, Error &error)
-{
-    error.Clear();
+void IRMemoryMap::Leak(lldb::addr_t process_address, Error &error) {
+  error.Clear();
 
-    AllocationMap::iterator iter = m_allocations.find(process_address);
+  AllocationMap::iterator iter = m_allocations.find(process_address);
 
-    if (iter == m_allocations.end())
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't leak: allocation doesn't exist");
-        return;
-    }
+  if (iter == m_allocations.end()) {
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't leak: allocation doesn't exist");
+    return;
+  }
 
-    Allocation &allocation = iter->second;
+  Allocation &allocation = iter->second;
 
-    allocation.m_leak = true;
+  allocation.m_leak = true;
 }
 
-void
-IRMemoryMap::Free (lldb::addr_t process_address, Error &error)
-{
-    error.Clear();
+void IRMemoryMap::Free(lldb::addr_t process_address, Error &error) {
+  error.Clear();
 
-    AllocationMap::iterator iter = m_allocations.find(process_address);
+  AllocationMap::iterator iter = m_allocations.find(process_address);
 
-    if (iter == m_allocations.end())
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't free: allocation doesn't exist");
-        return;
-    }
-
-    Allocation &allocation = iter->second;
+  if (iter == m_allocations.end()) {
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't free: allocation doesn't exist");
+    return;
+  }
 
-    switch (allocation.m_policy)
-    {
-    default:
-    case eAllocationPolicyHostOnly:
-        {
-            lldb::ProcessSP process_sp = m_process_wp.lock();
-            if (process_sp)
-            {
-                if (process_sp->CanJIT() && process_sp->IsAlive())
-                    process_sp->DeallocateMemory(allocation.m_process_alloc); // FindSpace allocated this for real
-            }
+  Allocation &allocation = iter->second;
 
-            break;
-        }
-    case eAllocationPolicyMirror:
-    case eAllocationPolicyProcessOnly:
-        {
-            lldb::ProcessSP process_sp = m_process_wp.lock();
-            if (process_sp)
-                process_sp->DeallocateMemory(allocation.m_process_alloc);
-        }
-    }
-
-    if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
-    {
-        log->Printf("IRMemoryMap::Free (0x%" PRIx64 ") freed [0x%" PRIx64 "..0x%" PRIx64 ")",
-                    (uint64_t)process_address,
-                    iter->second.m_process_start,
-                    iter->second.m_process_start + iter->second.m_size);
+  switch (allocation.m_policy) {
+  default:
+  case eAllocationPolicyHostOnly: {
+    lldb::ProcessSP process_sp = m_process_wp.lock();
+    if (process_sp) {
+      if (process_sp->CanJIT() && process_sp->IsAlive())
+        process_sp->DeallocateMemory(
+            allocation.m_process_alloc); // FindSpace allocated this for real
     }
 
-    m_allocations.erase(iter);
+    break;
+  }
+  case eAllocationPolicyMirror:
+  case eAllocationPolicyProcessOnly: {
+    lldb::ProcessSP process_sp = m_process_wp.lock();
+    if (process_sp)
+      process_sp->DeallocateMemory(allocation.m_process_alloc);
+  }
+  }
+
+  if (lldb_private::Log *log =
+          lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
+    log->Printf("IRMemoryMap::Free (0x%" PRIx64 ") freed [0x%" PRIx64
+                "..0x%" PRIx64 ")",
+                (uint64_t)process_address, iter->second.m_process_start,
+                iter->second.m_process_start + iter->second.m_size);
+  }
+
+  m_allocations.erase(iter);
 }
 
-bool
-IRMemoryMap::GetAllocSize(lldb::addr_t address, size_t &size)
-{
-    AllocationMap::iterator iter = FindAllocation(address, size);
-    if (iter == m_allocations.end())
-        return false;
-
-    Allocation &al = iter->second;
+bool IRMemoryMap::GetAllocSize(lldb::addr_t address, size_t &size) {
+  AllocationMap::iterator iter = FindAllocation(address, size);
+  if (iter == m_allocations.end())
+    return false;
 
-    if (address > (al.m_process_start + al.m_size))
-    {
-        size = 0;
-        return false;
-    }
+  Allocation &al = iter->second;
 
-    if (address > al.m_process_start)
-    {
-        int dif = address - al.m_process_start;
-        size = al.m_size - dif;
-        return true;
-    }
+  if (address > (al.m_process_start + al.m_size)) {
+    size = 0;
+    return false;
+  }
 
-    size = al.m_size;
+  if (address > al.m_process_start) {
+    int dif = address - al.m_process_start;
+    size = al.m_size - dif;
     return true;
-}
+  }
 
-void
-IRMemoryMap::WriteMemory (lldb::addr_t process_address, const uint8_t *bytes, size_t size, Error &error)
-{
-    error.Clear();
+  size = al.m_size;
+  return true;
+}
 
-    AllocationMap::iterator iter = FindAllocation(process_address, size);
+void IRMemoryMap::WriteMemory(lldb::addr_t process_address,
+                              const uint8_t *bytes, size_t size, Error &error) {
+  error.Clear();
 
-    if (iter == m_allocations.end())
-    {
-        lldb::ProcessSP process_sp = m_process_wp.lock();
+  AllocationMap::iterator iter = FindAllocation(process_address, size);
 
-        if (process_sp)
-        {
-            process_sp->WriteMemory(process_address, bytes, size, error);
-            return;
-        }
+  if (iter == m_allocations.end()) {
+    lldb::ProcessSP process_sp = m_process_wp.lock();
 
-        error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't write: no allocation contains the target range and the process doesn't exist");
-        return;
+    if (process_sp) {
+      process_sp->WriteMemory(process_address, bytes, size, error);
+      return;
     }
 
-    Allocation &allocation = iter->second;
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't write: no allocation contains the target "
+                         "range and the process doesn't exist");
+    return;
+  }
 
-    uint64_t offset = process_address - allocation.m_process_start;
+  Allocation &allocation = iter->second;
 
-    lldb::ProcessSP process_sp;
+  uint64_t offset = process_address - allocation.m_process_start;
 
-    switch (allocation.m_policy)
-    {
-    default:
-        error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't write: invalid allocation policy");
+  lldb::ProcessSP process_sp;
+
+  switch (allocation.m_policy) {
+  default:
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't write: invalid allocation policy");
+    return;
+  case eAllocationPolicyHostOnly:
+    if (!allocation.m_data.GetByteSize()) {
+      error.SetErrorToGenericError();
+      error.SetErrorString("Couldn't write: data buffer is empty");
+      return;
+    }
+    ::memcpy(allocation.m_data.GetBytes() + offset, bytes, size);
+    break;
+  case eAllocationPolicyMirror:
+    if (!allocation.m_data.GetByteSize()) {
+      error.SetErrorToGenericError();
+      error.SetErrorString("Couldn't write: data buffer is empty");
+      return;
+    }
+    ::memcpy(allocation.m_data.GetBytes() + offset, bytes, size);
+    process_sp = m_process_wp.lock();
+    if (process_sp) {
+      process_sp->WriteMemory(process_address, bytes, size, error);
+      if (!error.Success())
         return;
-    case eAllocationPolicyHostOnly:
-        if (!allocation.m_data.GetByteSize())
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorString("Couldn't write: data buffer is empty");
-            return;
-        }
-        ::memcpy (allocation.m_data.GetBytes() + offset, bytes, size);
-        break;
-    case eAllocationPolicyMirror:
-        if (!allocation.m_data.GetByteSize())
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorString("Couldn't write: data buffer is empty");
-            return;
-        }
-        ::memcpy (allocation.m_data.GetBytes() + offset, bytes, size);
-        process_sp = m_process_wp.lock();
-        if (process_sp)
-        {
-            process_sp->WriteMemory(process_address, bytes, size, error);
-            if (!error.Success())
-                return;
-        }
-        break;
-    case eAllocationPolicyProcessOnly:
-        process_sp = m_process_wp.lock();
-        if (process_sp)
-        {
-            process_sp->WriteMemory(process_address, bytes, size, error);
-            if (!error.Success())
-                return;
-        }
-        break;
     }
-
-    if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
-    {
-        log->Printf("IRMemoryMap::WriteMemory (0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRId64 ") went to [0x%" PRIx64 "..0x%" PRIx64 ")",
-                    (uint64_t)process_address,
-                    (uint64_t)bytes,
-                    (uint64_t)size,
-                    (uint64_t)allocation.m_process_start,
-                    (uint64_t)allocation.m_process_start + (uint64_t)allocation.m_size);
+    break;
+  case eAllocationPolicyProcessOnly:
+    process_sp = m_process_wp.lock();
+    if (process_sp) {
+      process_sp->WriteMemory(process_address, bytes, size, error);
+      if (!error.Success())
+        return;
     }
+    break;
+  }
+
+  if (lldb_private::Log *log =
+          lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
+    log->Printf("IRMemoryMap::WriteMemory (0x%" PRIx64 ", 0x%" PRIx64
+                ", 0x%" PRId64 ") went to [0x%" PRIx64 "..0x%" PRIx64 ")",
+                (uint64_t)process_address, (uint64_t)bytes, (uint64_t)size,
+                (uint64_t)allocation.m_process_start,
+                (uint64_t)allocation.m_process_start +
+                    (uint64_t)allocation.m_size);
+  }
 }
 
-void
-IRMemoryMap::WriteScalarToMemory (lldb::addr_t process_address, Scalar &scalar, size_t size, Error &error)
-{
-    error.Clear();
-
-    if (size == UINT32_MAX)
-        size = scalar.GetByteSize();
-
-    if (size > 0)
-    {
-        uint8_t buf[32];
-        const size_t mem_size = scalar.GetAsMemoryData (buf, size, GetByteOrder(), error);
-        if (mem_size > 0)
-        {
-            return WriteMemory(process_address, buf, mem_size, error);
-        }
-        else
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorString ("Couldn't write scalar: failed to get scalar as memory data");
-        }
-    }
-    else
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorString ("Couldn't write scalar: its size was zero");
-    }
-    return;
+void IRMemoryMap::WriteScalarToMemory(lldb::addr_t process_address,
+                                      Scalar &scalar, size_t size,
+                                      Error &error) {
+  error.Clear();
+
+  if (size == UINT32_MAX)
+    size = scalar.GetByteSize();
+
+  if (size > 0) {
+    uint8_t buf[32];
+    const size_t mem_size =
+        scalar.GetAsMemoryData(buf, size, GetByteOrder(), error);
+    if (mem_size > 0) {
+      return WriteMemory(process_address, buf, mem_size, error);
+    } else {
+      error.SetErrorToGenericError();
+      error.SetErrorString(
+          "Couldn't write scalar: failed to get scalar as memory data");
+    }
+  } else {
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't write scalar: its size was zero");
+  }
+  return;
 }
 
-void
-IRMemoryMap::WritePointerToMemory (lldb::addr_t process_address, lldb::addr_t address, Error &error)
-{
-    error.Clear();
+void IRMemoryMap::WritePointerToMemory(lldb::addr_t process_address,
+                                       lldb::addr_t address, Error &error) {
+  error.Clear();
 
-    Scalar scalar(address);
+  Scalar scalar(address);
 
-    WriteScalarToMemory(process_address, scalar, GetAddressByteSize(), error);
+  WriteScalarToMemory(process_address, scalar, GetAddressByteSize(), error);
 }
 
-void
-IRMemoryMap::ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t size, Error &error)
-{
-    error.Clear();
+void IRMemoryMap::ReadMemory(uint8_t *bytes, lldb::addr_t process_address,
+                             size_t size, Error &error) {
+  error.Clear();
 
-    AllocationMap::iterator iter = FindAllocation(process_address, size);
-
-    if (iter == m_allocations.end())
-    {
-        lldb::ProcessSP process_sp = m_process_wp.lock();
+  AllocationMap::iterator iter = FindAllocation(process_address, size);
 
-        if (process_sp)
-        {
-            process_sp->ReadMemory(process_address, bytes, size, error);
-            return;
-        }
+  if (iter == m_allocations.end()) {
+    lldb::ProcessSP process_sp = m_process_wp.lock();
 
-        lldb::TargetSP target_sp = m_target_wp.lock();
+    if (process_sp) {
+      process_sp->ReadMemory(process_address, bytes, size, error);
+      return;
+    }
 
-        if (target_sp)
-        {
-            Address absolute_address(process_address);
-            target_sp->ReadMemory(absolute_address, false, bytes, size, error);
-            return;
-        }
+    lldb::TargetSP target_sp = m_target_wp.lock();
 
-        error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't read: no allocation contains the target range, and neither the process nor the target exist");
-        return;
+    if (target_sp) {
+      Address absolute_address(process_address);
+      target_sp->ReadMemory(absolute_address, false, bytes, size, error);
+      return;
     }
 
-    Allocation &allocation = iter->second;
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't read: no allocation contains the target "
+                         "range, and neither the process nor the target exist");
+    return;
+  }
 
-    uint64_t offset = process_address - allocation.m_process_start;
+  Allocation &allocation = iter->second;
 
-    if (offset > allocation.m_size)
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't read: data is not in the allocation");
-        return;
-    }
+  uint64_t offset = process_address - allocation.m_process_start;
 
-    lldb::ProcessSP process_sp;
+  if (offset > allocation.m_size) {
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't read: data is not in the allocation");
+    return;
+  }
 
-    switch (allocation.m_policy)
-    {
-    default:
+  lldb::ProcessSP process_sp;
+
+  switch (allocation.m_policy) {
+  default:
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't read: invalid allocation policy");
+    return;
+  case eAllocationPolicyHostOnly:
+    if (!allocation.m_data.GetByteSize()) {
+      error.SetErrorToGenericError();
+      error.SetErrorString("Couldn't read: data buffer is empty");
+      return;
+    }
+    if (allocation.m_data.GetByteSize() < offset + size) {
+      error.SetErrorToGenericError();
+      error.SetErrorString("Couldn't read: not enough underlying data");
+      return;
+    }
+
+    ::memcpy(bytes, allocation.m_data.GetBytes() + offset, size);
+    break;
+  case eAllocationPolicyMirror:
+    process_sp = m_process_wp.lock();
+    if (process_sp) {
+      process_sp->ReadMemory(process_address, bytes, size, error);
+      if (!error.Success())
+        return;
+    } else {
+      if (!allocation.m_data.GetByteSize()) {
         error.SetErrorToGenericError();
-        error.SetErrorString("Couldn't read: invalid allocation policy");
+        error.SetErrorString("Couldn't read: data buffer is empty");
+        return;
+      }
+      ::memcpy(bytes, allocation.m_data.GetBytes() + offset, size);
+    }
+    break;
+  case eAllocationPolicyProcessOnly:
+    process_sp = m_process_wp.lock();
+    if (process_sp) {
+      process_sp->ReadMemory(process_address, bytes, size, error);
+      if (!error.Success())
         return;
-    case eAllocationPolicyHostOnly:
-        if (!allocation.m_data.GetByteSize())
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorString("Couldn't read: data buffer is empty");
-            return;
-        }
-        if (allocation.m_data.GetByteSize() < offset + size)
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorString("Couldn't read: not enough underlying data");
-            return;
-        }
-
-        ::memcpy (bytes, allocation.m_data.GetBytes() + offset, size);
-        break;
-    case eAllocationPolicyMirror:
-        process_sp = m_process_wp.lock();
-        if (process_sp)
-        {
-            process_sp->ReadMemory(process_address, bytes, size, error);
-            if (!error.Success())
-                return;
-        }
-        else
-        {
-            if (!allocation.m_data.GetByteSize())
-            {
-                error.SetErrorToGenericError();
-                error.SetErrorString("Couldn't read: data buffer is empty");
-                return;
-            }
-            ::memcpy (bytes, allocation.m_data.GetBytes() + offset, size);
-        }
-        break;
-    case eAllocationPolicyProcessOnly:
-        process_sp = m_process_wp.lock();
-        if (process_sp)
-        {
-            process_sp->ReadMemory(process_address, bytes, size, error);
-            if (!error.Success())
-                return;
-        }
-        break;
-    }
-
-    if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
-    {
-        log->Printf("IRMemoryMap::ReadMemory (0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRId64 ") came from [0x%" PRIx64 "..0x%" PRIx64 ")",
-                    (uint64_t)process_address,
-                    (uint64_t)bytes,
-                    (uint64_t)size,
-                    (uint64_t)allocation.m_process_start,
-                    (uint64_t)allocation.m_process_start + (uint64_t)allocation.m_size);
     }
+    break;
+  }
+
+  if (lldb_private::Log *log =
+          lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
+    log->Printf("IRMemoryMap::ReadMemory (0x%" PRIx64 ", 0x%" PRIx64
+                ", 0x%" PRId64 ") came from [0x%" PRIx64 "..0x%" PRIx64 ")",
+                (uint64_t)process_address, (uint64_t)bytes, (uint64_t)size,
+                (uint64_t)allocation.m_process_start,
+                (uint64_t)allocation.m_process_start +
+                    (uint64_t)allocation.m_size);
+  }
 }
 
-void
-IRMemoryMap::ReadScalarFromMemory (Scalar &scalar, lldb::addr_t process_address, size_t size, Error &error)
-{
-    error.Clear();
+void IRMemoryMap::ReadScalarFromMemory(Scalar &scalar,
+                                       lldb::addr_t process_address,
+                                       size_t size, Error &error) {
+  error.Clear();
 
-    if (size > 0)
-    {
-        DataBufferHeap buf(size, 0);
-        ReadMemory(buf.GetBytes(), process_address, size, error);
+  if (size > 0) {
+    DataBufferHeap buf(size, 0);
+    ReadMemory(buf.GetBytes(), process_address, size, error);
 
-        if (!error.Success())
-            return;
-
-        DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(), GetAddressByteSize());
-
-        lldb::offset_t offset = 0;
-
-        switch (size)
-        {
-        default:
-            error.SetErrorToGenericError();
-            error.SetErrorStringWithFormat("Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
-            return;
-        case 1: scalar = extractor.GetU8(&offset);  break;
-        case 2: scalar = extractor.GetU16(&offset); break;
-        case 4: scalar = extractor.GetU32(&offset); break;
-        case 8: scalar = extractor.GetU64(&offset); break;
-        }
-    }
-    else
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorString ("Couldn't read scalar: its size was zero");
-    }
-    return;
-}
+    if (!error.Success())
+      return;
 
-void
-IRMemoryMap::ReadPointerFromMemory (lldb::addr_t *address, lldb::addr_t process_address, Error &error)
-{
-    error.Clear();
+    DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(),
+                            GetAddressByteSize());
 
-    Scalar pointer_scalar;
-    ReadScalarFromMemory(pointer_scalar, process_address, GetAddressByteSize(), error);
+    lldb::offset_t offset = 0;
 
-    if (!error.Success())
-        return;
+    switch (size) {
+    default:
+      error.SetErrorToGenericError();
+      error.SetErrorStringWithFormat(
+          "Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
+      return;
+    case 1:
+      scalar = extractor.GetU8(&offset);
+      break;
+    case 2:
+      scalar = extractor.GetU16(&offset);
+      break;
+    case 4:
+      scalar = extractor.GetU32(&offset);
+      break;
+    case 8:
+      scalar = extractor.GetU64(&offset);
+      break;
+    }
+  } else {
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't read scalar: its size was zero");
+  }
+  return;
+}
+
+void IRMemoryMap::ReadPointerFromMemory(lldb::addr_t *address,
+                                        lldb::addr_t process_address,
+                                        Error &error) {
+  error.Clear();
 
-    *address = pointer_scalar.ULongLong();
+  Scalar pointer_scalar;
+  ReadScalarFromMemory(pointer_scalar, process_address, GetAddressByteSize(),
+                       error);
 
+  if (!error.Success())
     return;
-}
 
-void
-IRMemoryMap::GetMemoryData (DataExtractor &extractor, lldb::addr_t process_address, size_t size, Error &error)
-{
-    error.Clear();
+  *address = pointer_scalar.ULongLong();
 
-    if (size > 0)
-    {
-        AllocationMap::iterator iter = FindAllocation(process_address, size);
+  return;
+}
 
-        if (iter == m_allocations.end())
-        {
-            error.SetErrorToGenericError();
-            error.SetErrorStringWithFormat("Couldn't find an allocation containing [0x%" PRIx64 "..0x%" PRIx64 ")", process_address, process_address + size);
-            return;
-        }
+void IRMemoryMap::GetMemoryData(DataExtractor &extractor,
+                                lldb::addr_t process_address, size_t size,
+                                Error &error) {
+  error.Clear();
 
-        Allocation &allocation = iter->second;
-
-        switch (allocation.m_policy)
-        {
-        default:
-            error.SetErrorToGenericError();
-            error.SetErrorString("Couldn't get memory data: invalid allocation policy");
-            return;
-        case eAllocationPolicyProcessOnly:
-            error.SetErrorToGenericError();
-            error.SetErrorString("Couldn't get memory data: memory is only in the target");
-            return;
-        case eAllocationPolicyMirror:
-            {
-                lldb::ProcessSP process_sp = m_process_wp.lock();
-
-                if (!allocation.m_data.GetByteSize())
-                {
-                    error.SetErrorToGenericError();
-                    error.SetErrorString("Couldn't get memory data: data buffer is empty");
-                    return;
-                }
-                if (process_sp)
-                {
-                    process_sp->ReadMemory(allocation.m_process_start, allocation.m_data.GetBytes(), allocation.m_data.GetByteSize(), error);
-                    if (!error.Success())
-                        return;
-                    uint64_t offset = process_address - allocation.m_process_start;
-                    extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size, GetByteOrder(), GetAddressByteSize());
-                    return;
-                }
-            }
-            break;
-        case eAllocationPolicyHostOnly:
-            if (!allocation.m_data.GetByteSize())
-            {
-                error.SetErrorToGenericError();
-                error.SetErrorString("Couldn't get memory data: data buffer is empty");
-                return;
-            }
-            uint64_t offset = process_address - allocation.m_process_start;
-            extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size, GetByteOrder(), GetAddressByteSize());
-            return;
-        }
+  if (size > 0) {
+    AllocationMap::iterator iter = FindAllocation(process_address, size);
+
+    if (iter == m_allocations.end()) {
+      error.SetErrorToGenericError();
+      error.SetErrorStringWithFormat(
+          "Couldn't find an allocation containing [0x%" PRIx64 "..0x%" PRIx64
+          ")",
+          process_address, process_address + size);
+      return;
     }
-    else
-    {
+
+    Allocation &allocation = iter->second;
+
+    switch (allocation.m_policy) {
+    default:
+      error.SetErrorToGenericError();
+      error.SetErrorString(
+          "Couldn't get memory data: invalid allocation policy");
+      return;
+    case eAllocationPolicyProcessOnly:
+      error.SetErrorToGenericError();
+      error.SetErrorString(
+          "Couldn't get memory data: memory is only in the target");
+      return;
+    case eAllocationPolicyMirror: {
+      lldb::ProcessSP process_sp = m_process_wp.lock();
+
+      if (!allocation.m_data.GetByteSize()) {
         error.SetErrorToGenericError();
-        error.SetErrorString ("Couldn't get memory data: its size was zero");
+        error.SetErrorString("Couldn't get memory data: data buffer is empty");
         return;
-    }
+      }
+      if (process_sp) {
+        process_sp->ReadMemory(allocation.m_process_start,
+                               allocation.m_data.GetBytes(),
+                               allocation.m_data.GetByteSize(), error);
+        if (!error.Success())
+          return;
+        uint64_t offset = process_address - allocation.m_process_start;
+        extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size,
+                                  GetByteOrder(), GetAddressByteSize());
+        return;
+      }
+    } break;
+    case eAllocationPolicyHostOnly:
+      if (!allocation.m_data.GetByteSize()) {
+        error.SetErrorToGenericError();
+        error.SetErrorString("Couldn't get memory data: data buffer is empty");
+        return;
+      }
+      uint64_t offset = process_address - allocation.m_process_start;
+      extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size,
+                                GetByteOrder(), GetAddressByteSize());
+      return;
+    }
+  } else {
+    error.SetErrorToGenericError();
+    error.SetErrorString("Couldn't get memory data: its size was zero");
+    return;
+  }
 }