contrib/llvm-project/lldb/source/Expression/IRMemoryMap.cpp

   1 //===-- IRMemoryMap.cpp -----------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Expression/IRMemoryMap.h"
  10 #include "lldb/Target/MemoryRegionInfo.h"
  11 #include "lldb/Target/Process.h"
  12 #include "lldb/Target/Target.h"
  13 #include "lldb/Utility/DataBufferHeap.h"
  14 #include "lldb/Utility/DataExtractor.h"
  15 #include "lldb/Utility/LLDBAssert.h"
  16 #include "lldb/Utility/Log.h"
  17 #include "lldb/Utility/Scalar.h"
  18 #include "lldb/Utility/Status.h"
  19
  20 using namespace lldb_private;
  21
  22 IRMemoryMap::IRMemoryMap(lldb::TargetSP target_sp) : m_target_wp(target_sp) {
  23   if (target_sp)
  24     m_process_wp = target_sp->GetProcessSP();
  25 }
  26
  27 IRMemoryMap::~IRMemoryMap() {
  28   lldb::ProcessSP process_sp = m_process_wp.lock();
  29
  30   if (process_sp) {
  31     AllocationMap::iterator iter;
  32
  33     Status err;
  34
  35     while ((iter = m_allocations.begin()) != m_allocations.end()) {
  36       err.Clear();
  37       if (iter->second.m_leak)
  38         m_allocations.erase(iter);
  39       else
  40         Free(iter->first, err);
  41     }
  42   }
  43 }
  44
  45 lldb::addr_t IRMemoryMap::FindSpace(size_t size) {
  46   // The FindSpace algorithm's job is to find a region of memory that the
  47   // underlying process is unlikely to be using.
  48   //
  49   // The memory returned by this function will never be written to.  The only
  50   // point is that it should not shadow process memory if possible, so that
  51   // expressions processing real values from the process do not use the wrong
  52   // data.
  53   //
  54   // If the process can in fact allocate memory (CanJIT() lets us know this)
  55   // then this can be accomplished just be allocating memory in the inferior.
  56   // Then no guessing is required.
  57
  58   lldb::TargetSP target_sp = m_target_wp.lock();
  59   lldb::ProcessSP process_sp = m_process_wp.lock();
  60
  61   const bool process_is_alive = process_sp && process_sp->IsAlive();
  62
  63   lldb::addr_t ret = LLDB_INVALID_ADDRESS;
  64   if (size == 0)
  65     return ret;
  66
  67   if (process_is_alive && process_sp->CanJIT()) {
  68     Status alloc_error;
  69
  70     ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable |
  71                                                lldb::ePermissionsWritable,
  72                                      alloc_error);
  73
  74     if (!alloc_error.Success())
  75       return LLDB_INVALID_ADDRESS;
  76     else
  77       return ret;
  78   }
  79
  80   // At this point we know that we need to hunt.
  81   //
  82   // First, go to the end of the existing allocations we've made if there are
  83   // any allocations.  Otherwise start at the beginning of memory.
  84
  85   if (m_allocations.empty()) {
  86     ret = 0x0;
  87   } else {
  88     auto back = m_allocations.rbegin();
  89     lldb::addr_t addr = back->first;
  90     size_t alloc_size = back->second.m_size;
  91     ret = llvm::alignTo(addr + alloc_size, 4096);
  92   }
  93
  94   // Now, if it's possible to use the GetMemoryRegionInfo API to detect mapped
  95   // regions, walk forward through memory until a region is found that has
  96   // adequate space for our allocation.
  97   if (process_is_alive) {
  98     const uint64_t end_of_memory = process_sp->GetAddressByteSize() == 8
  99                                        ? 0xffffffffffffffffull
 100                                        : 0xffffffffull;
 101
 102     lldbassert(process_sp->GetAddressByteSize() == 4 ||
 103                end_of_memory != 0xffffffffull);
 104
 105     MemoryRegionInfo region_info;
 106     Status err = process_sp->GetMemoryRegionInfo(ret, region_info);
 107     if (err.Success()) {
 108       while (true) {
 109         if (region_info.GetReadable() != MemoryRegionInfo::OptionalBool::eNo ||
 110             region_info.GetWritable() != MemoryRegionInfo::OptionalBool::eNo ||
 111             region_info.GetExecutable() !=
 112                 MemoryRegionInfo::OptionalBool::eNo) {
 113           if (region_info.GetRange().GetRangeEnd() - 1 >= end_of_memory) {
 114             ret = LLDB_INVALID_ADDRESS;
 115             break;
 116           } else {
 117             ret = region_info.GetRange().GetRangeEnd();
 118           }
 119         } else if (ret + size < region_info.GetRange().GetRangeEnd()) {
 120           return ret;
 121         } else {
 122           // ret stays the same.  We just need to walk a bit further.
 123         }
 124
 125         err = process_sp->GetMemoryRegionInfo(
 126             region_info.GetRange().GetRangeEnd(), region_info);
 127         if (err.Fail()) {
 128           lldbassert(0 && "GetMemoryRegionInfo() succeeded, then failed");
 129           ret = LLDB_INVALID_ADDRESS;
 130           break;
 131         }
 132       }
 133     }
 134   }
 135
 136   // We've tried our algorithm, and it didn't work.  Now we have to reset back
 137   // to the end of the allocations we've already reported, or use a 'sensible'
 138   // default if this is our first allocation.
 139
 140   if (m_allocations.empty()) {
 141     uint32_t address_byte_size = GetAddressByteSize();
 142     if (address_byte_size != UINT32_MAX) {
 143       switch (address_byte_size) {
 144       case 8:
 145         ret = 0xffffffff00000000ull;
 146         break;
 147       case 4:
 148         ret = 0xee000000ull;
 149         break;
 150       default:
 151         break;
 152       }
 153     }
 154   } else {
 155     auto back = m_allocations.rbegin();
 156     lldb::addr_t addr = back->first;
 157     size_t alloc_size = back->second.m_size;
 158     ret = llvm::alignTo(addr + alloc_size, 4096);
 159   }
 160
 161   return ret;
 162 }
 163
 164 IRMemoryMap::AllocationMap::iterator
 165 IRMemoryMap::FindAllocation(lldb::addr_t addr, size_t size) {
 166   if (addr == LLDB_INVALID_ADDRESS)
 167     return m_allocations.end();
 168
 169   AllocationMap::iterator iter = m_allocations.lower_bound(addr);
 170
 171   if (iter == m_allocations.end() || iter->first > addr) {
 172     if (iter == m_allocations.begin())
 173       return m_allocations.end();
 174     iter--;
 175   }
 176
 177   if (iter->first <= addr && iter->first + iter->second.m_size >= addr + size)
 178     return iter;
 179
 180   return m_allocations.end();
 181 }
 182
 183 bool IRMemoryMap::IntersectsAllocation(lldb::addr_t addr, size_t size) const {
 184   if (addr == LLDB_INVALID_ADDRESS)
 185     return false;
 186
 187   AllocationMap::const_iterator iter = m_allocations.lower_bound(addr);
 188
 189   // Since we only know that the returned interval begins at a location greater
 190   // than or equal to where the given interval begins, it's possible that the
 191   // given interval intersects either the returned interval or the previous
 192   // interval.  Thus, we need to check both. Note that we only need to check
 193   // these two intervals.  Since all intervals are disjoint it is not possible
 194   // that an adjacent interval does not intersect, but a non-adjacent interval
 195   // does intersect.
 196   if (iter != m_allocations.end()) {
 197     if (AllocationsIntersect(addr, size, iter->second.m_process_start,
 198                              iter->second.m_size))
 199       return true;
 200   }
 201
 202   if (iter != m_allocations.begin()) {
 203     --iter;
 204     if (AllocationsIntersect(addr, size, iter->second.m_process_start,
 205                              iter->second.m_size))
 206       return true;
 207   }
 208
 209   return false;
 210 }
 211
 212 bool IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1,
 213                                        lldb::addr_t addr2, size_t size2) {
 214   // Given two half open intervals [A, B) and [X, Y), the only 6 permutations
 215   // that satisfy A<B and X<Y are the following:
 216   // A B X Y
 217   // A X B Y  (intersects)
 218   // A X Y B  (intersects)
 219   // X A B Y  (intersects)
 220   // X A Y B  (intersects)
 221   // X Y A B
 222   // The first is B <= X, and the last is Y <= A. So the condition is !(B <= X
 223   // || Y <= A)), or (X < B && A < Y)
 224   return (addr2 < (addr1 + size1)) && (addr1 < (addr2 + size2));
 225 }
 226
 227 lldb::ByteOrder IRMemoryMap::GetByteOrder() {
 228   lldb::ProcessSP process_sp = m_process_wp.lock();
 229
 230   if (process_sp)
 231     return process_sp->GetByteOrder();
 232
 233   lldb::TargetSP target_sp = m_target_wp.lock();
 234
 235   if (target_sp)
 236     return target_sp->GetArchitecture().GetByteOrder();
 237
 238   return lldb::eByteOrderInvalid;
 239 }
 240
 241 uint32_t IRMemoryMap::GetAddressByteSize() {
 242   lldb::ProcessSP process_sp = m_process_wp.lock();
 243
 244   if (process_sp)
 245     return process_sp->GetAddressByteSize();
 246
 247   lldb::TargetSP target_sp = m_target_wp.lock();
 248
 249   if (target_sp)
 250     return target_sp->GetArchitecture().GetAddressByteSize();
 251
 252   return UINT32_MAX;
 253 }
 254
 255 ExecutionContextScope *IRMemoryMap::GetBestExecutionContextScope() const {
 256   lldb::ProcessSP process_sp = m_process_wp.lock();
 257
 258   if (process_sp)
 259     return process_sp.get();
 260
 261   lldb::TargetSP target_sp = m_target_wp.lock();
 262
 263   if (target_sp)
 264     return target_sp.get();
 265
 266   return nullptr;
 267 }
 268
 269 IRMemoryMap::Allocation::Allocation(lldb::addr_t process_alloc,
 270                                     lldb::addr_t process_start, size_t size,
 271                                     uint32_t permissions, uint8_t alignment,
 272                                     AllocationPolicy policy)
 273     : m_process_alloc(process_alloc), m_process_start(process_start),
 274       m_size(size), m_policy(policy), m_leak(false), m_permissions(permissions),
 275       m_alignment(alignment) {
 276   switch (policy) {
 277   default:
 278     llvm_unreachable("Invalid AllocationPolicy");
 279   case eAllocationPolicyHostOnly:
 280   case eAllocationPolicyMirror:
 281     m_data.SetByteSize(size);
 282     break;
 283   case eAllocationPolicyProcessOnly:
 284     break;
 285   }
 286 }
 287
 288 lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
 289                                  uint32_t permissions, AllocationPolicy policy,
 290                                  bool zero_memory, Status &error) {
 291   lldb_private::Log *log(
 292       lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 293   error.Clear();
 294
 295   lldb::ProcessSP process_sp;
 296   lldb::addr_t allocation_address = LLDB_INVALID_ADDRESS;
 297   lldb::addr_t aligned_address = LLDB_INVALID_ADDRESS;
 298
 299   size_t allocation_size;
 300
 301   if (size == 0) {
 302     // FIXME: Malloc(0) should either return an invalid address or assert, in
 303     // order to cut down on unnecessary allocations.
 304     allocation_size = alignment;
 305   } else {
 306     // Round up the requested size to an aligned value.
 307     allocation_size = llvm::alignTo(size, alignment);
 308
 309     // The process page cache does not see the requested alignment. We can't
 310     // assume its result will be any more than 1-byte aligned. To work around
 311     // this, request `alignment - 1` additional bytes.
 312     allocation_size += alignment - 1;
 313   }
 314
 315   switch (policy) {
 316   default:
 317     error.SetErrorToGenericError();
 318     error.SetErrorString("Couldn't malloc: invalid allocation policy");
 319     return LLDB_INVALID_ADDRESS;
 320   case eAllocationPolicyHostOnly:
 321     allocation_address = FindSpace(allocation_size);
 322     if (allocation_address == LLDB_INVALID_ADDRESS) {
 323       error.SetErrorToGenericError();
 324       error.SetErrorString("Couldn't malloc: address space is full");
 325       return LLDB_INVALID_ADDRESS;
 326     }
 327     break;
 328   case eAllocationPolicyMirror:
 329     process_sp = m_process_wp.lock();
 330     LLDB_LOGF(log,
 331               "IRMemoryMap::%s process_sp=0x%" PRIx64
 332               ", process_sp->CanJIT()=%s, process_sp->IsAlive()=%s",
 333               __FUNCTION__, (lldb::addr_t)process_sp.get(),
 334               process_sp && process_sp->CanJIT() ? "true" : "false",
 335               process_sp && process_sp->IsAlive() ? "true" : "false");
 336     if (process_sp && process_sp->CanJIT() && process_sp->IsAlive()) {
 337       if (!zero_memory)
 338         allocation_address =
 339             process_sp->AllocateMemory(allocation_size, permissions, error);
 340       else
 341         allocation_address =
 342             process_sp->CallocateMemory(allocation_size, permissions, error);
 343
 344       if (!error.Success())
 345         return LLDB_INVALID_ADDRESS;
 346     } else {
 347       LLDB_LOGF(log,
 348                 "IRMemoryMap::%s switching to eAllocationPolicyHostOnly "
 349                 "due to failed condition (see previous expr log message)",
 350                 __FUNCTION__);
 351       policy = eAllocationPolicyHostOnly;
 352       allocation_address = FindSpace(allocation_size);
 353       if (allocation_address == LLDB_INVALID_ADDRESS) {
 354         error.SetErrorToGenericError();
 355         error.SetErrorString("Couldn't malloc: address space is full");
 356         return LLDB_INVALID_ADDRESS;
 357       }
 358     }
 359     break;
 360   case eAllocationPolicyProcessOnly:
 361     process_sp = m_process_wp.lock();
 362     if (process_sp) {
 363       if (process_sp->CanJIT() && process_sp->IsAlive()) {
 364         if (!zero_memory)
 365           allocation_address =
 366               process_sp->AllocateMemory(allocation_size, permissions, error);
 367         else
 368           allocation_address =
 369               process_sp->CallocateMemory(allocation_size, permissions, error);
 370
 371         if (!error.Success())
 372           return LLDB_INVALID_ADDRESS;
 373       } else {
 374         error.SetErrorToGenericError();
 375         error.SetErrorString(
 376             "Couldn't malloc: process doesn't support allocating memory");
 377         return LLDB_INVALID_ADDRESS;
 378       }
 379     } else {
 380       error.SetErrorToGenericError();
 381       error.SetErrorString("Couldn't malloc: process doesn't exist, and this "
 382                            "memory must be in the process");
 383       return LLDB_INVALID_ADDRESS;
 384     }
 385     break;
 386   }
 387
 388   lldb::addr_t mask = alignment - 1;
 389   aligned_address = (allocation_address + mask) & (~mask);
 390
 391   m_allocations.emplace(
 392       std::piecewise_construct, std::forward_as_tuple(aligned_address),
 393       std::forward_as_tuple(allocation_address, aligned_address,
 394                             allocation_size, permissions, alignment, policy));
 395
 396   if (zero_memory) {
 397     Status write_error;
 398     std::vector<uint8_t> zero_buf(size, 0);
 399     WriteMemory(aligned_address, zero_buf.data(), size, write_error);
 400   }
 401
 402   if (log) {
 403     const char *policy_string;
 404
 405     switch (policy) {
 406     default:
 407       policy_string = "<invalid policy>";
 408       break;
 409     case eAllocationPolicyHostOnly:
 410       policy_string = "eAllocationPolicyHostOnly";
 411       break;
 412     case eAllocationPolicyProcessOnly:
 413       policy_string = "eAllocationPolicyProcessOnly";
 414       break;
 415     case eAllocationPolicyMirror:
 416       policy_string = "eAllocationPolicyMirror";
 417       break;
 418     }
 419
 420     LLDB_LOGF(log,
 421               "IRMemoryMap::Malloc (%" PRIu64 ", 0x%" PRIx64 ", 0x%" PRIx64
 422               ", %s) -> 0x%" PRIx64,
 423               (uint64_t)allocation_size, (uint64_t)alignment,
 424               (uint64_t)permissions, policy_string, aligned_address);
 425   }
 426
 427   return aligned_address;
 428 }
 429
 430 void IRMemoryMap::Leak(lldb::addr_t process_address, Status &error) {
 431   error.Clear();
 432
 433   AllocationMap::iterator iter = m_allocations.find(process_address);
 434
 435   if (iter == m_allocations.end()) {
 436     error.SetErrorToGenericError();
 437     error.SetErrorString("Couldn't leak: allocation doesn't exist");
 438     return;
 439   }
 440
 441   Allocation &allocation = iter->second;
 442
 443   allocation.m_leak = true;
 444 }
 445
 446 void IRMemoryMap::Free(lldb::addr_t process_address, Status &error) {
 447   error.Clear();
 448
 449   AllocationMap::iterator iter = m_allocations.find(process_address);
 450
 451   if (iter == m_allocations.end()) {
 452     error.SetErrorToGenericError();
 453     error.SetErrorString("Couldn't free: allocation doesn't exist");
 454     return;
 455   }
 456
 457   Allocation &allocation = iter->second;
 458
 459   switch (allocation.m_policy) {
 460   default:
 461   case eAllocationPolicyHostOnly: {
 462     lldb::ProcessSP process_sp = m_process_wp.lock();
 463     if (process_sp) {
 464       if (process_sp->CanJIT() && process_sp->IsAlive())
 465         process_sp->DeallocateMemory(
 466             allocation.m_process_alloc); // FindSpace allocated this for real
 467     }
 468
 469     break;
 470   }
 471   case eAllocationPolicyMirror:
 472   case eAllocationPolicyProcessOnly: {
 473     lldb::ProcessSP process_sp = m_process_wp.lock();
 474     if (process_sp)
 475       process_sp->DeallocateMemory(allocation.m_process_alloc);
 476   }
 477   }
 478
 479   if (lldb_private::Log *log =
 480           lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
 481     LLDB_LOGF(log,
 482               "IRMemoryMap::Free (0x%" PRIx64 ") freed [0x%" PRIx64
 483               "..0x%" PRIx64 ")",
 484               (uint64_t)process_address, iter->second.m_process_start,
 485               iter->second.m_process_start + iter->second.m_size);
 486   }
 487
 488   m_allocations.erase(iter);
 489 }
 490
 491 bool IRMemoryMap::GetAllocSize(lldb::addr_t address, size_t &size) {
 492   AllocationMap::iterator iter = FindAllocation(address, size);
 493   if (iter == m_allocations.end())
 494     return false;
 495
 496   Allocation &al = iter->second;
 497
 498   if (address > (al.m_process_start + al.m_size)) {
 499     size = 0;
 500     return false;
 501   }
 502
 503   if (address > al.m_process_start) {
 504     int dif = address - al.m_process_start;
 505     size = al.m_size - dif;
 506     return true;
 507   }
 508
 509   size = al.m_size;
 510   return true;
 511 }
 512
 513 void IRMemoryMap::WriteMemory(lldb::addr_t process_address,
 514                               const uint8_t *bytes, size_t size,
 515                               Status &error) {
 516   error.Clear();
 517
 518   AllocationMap::iterator iter = FindAllocation(process_address, size);
 519
 520   if (iter == m_allocations.end()) {
 521     lldb::ProcessSP process_sp = m_process_wp.lock();
 522
 523     if (process_sp) {
 524       process_sp->WriteMemory(process_address, bytes, size, error);
 525       return;
 526     }
 527
 528     error.SetErrorToGenericError();
 529     error.SetErrorString("Couldn't write: no allocation contains the target "
 530                          "range and the process doesn't exist");
 531     return;
 532   }
 533
 534   Allocation &allocation = iter->second;
 535
 536   uint64_t offset = process_address - allocation.m_process_start;
 537
 538   lldb::ProcessSP process_sp;
 539
 540   switch (allocation.m_policy) {
 541   default:
 542     error.SetErrorToGenericError();
 543     error.SetErrorString("Couldn't write: invalid allocation policy");
 544     return;
 545   case eAllocationPolicyHostOnly:
 546     if (!allocation.m_data.GetByteSize()) {
 547       error.SetErrorToGenericError();
 548       error.SetErrorString("Couldn't write: data buffer is empty");
 549       return;
 550     }
 551     ::memcpy(allocation.m_data.GetBytes() + offset, bytes, size);
 552     break;
 553   case eAllocationPolicyMirror:
 554     if (!allocation.m_data.GetByteSize()) {
 555       error.SetErrorToGenericError();
 556       error.SetErrorString("Couldn't write: data buffer is empty");
 557       return;
 558     }
 559     ::memcpy(allocation.m_data.GetBytes() + offset, bytes, size);
 560     process_sp = m_process_wp.lock();
 561     if (process_sp) {
 562       process_sp->WriteMemory(process_address, bytes, size, error);
 563       if (!error.Success())
 564         return;
 565     }
 566     break;
 567   case eAllocationPolicyProcessOnly:
 568     process_sp = m_process_wp.lock();
 569     if (process_sp) {
 570       process_sp->WriteMemory(process_address, bytes, size, error);
 571       if (!error.Success())
 572         return;
 573     }
 574     break;
 575   }
 576
 577   if (lldb_private::Log *log =
 578           lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
 579     LLDB_LOGF(log,
 580               "IRMemoryMap::WriteMemory (0x%" PRIx64 ", 0x%" PRIx64
 581               ", 0x%" PRId64 ") went to [0x%" PRIx64 "..0x%" PRIx64 ")",
 582               (uint64_t)process_address, (uint64_t)bytes, (uint64_t)size,
 583               (uint64_t)allocation.m_process_start,
 584               (uint64_t)allocation.m_process_start +
 585                   (uint64_t)allocation.m_size);
 586   }
 587 }
 588
 589 void IRMemoryMap::WriteScalarToMemory(lldb::addr_t process_address,
 590                                       Scalar &scalar, size_t size,
 591                                       Status &error) {
 592   error.Clear();
 593
 594   if (size == UINT32_MAX)
 595     size = scalar.GetByteSize();
 596
 597   if (size > 0) {
 598     uint8_t buf[32];
 599     const size_t mem_size =
 600         scalar.GetAsMemoryData(buf, size, GetByteOrder(), error);
 601     if (mem_size > 0) {
 602       return WriteMemory(process_address, buf, mem_size, error);
 603     } else {
 604       error.SetErrorToGenericError();
 605       error.SetErrorString(
 606           "Couldn't write scalar: failed to get scalar as memory data");
 607     }
 608   } else {
 609     error.SetErrorToGenericError();
 610     error.SetErrorString("Couldn't write scalar: its size was zero");
 611   }
 612   return;
 613 }
 614
 615 void IRMemoryMap::WritePointerToMemory(lldb::addr_t process_address,
 616                                        lldb::addr_t address, Status &error) {
 617   error.Clear();
 618
 619   Scalar scalar(address);
 620
 621   WriteScalarToMemory(process_address, scalar, GetAddressByteSize(), error);
 622 }
 623
 624 void IRMemoryMap::ReadMemory(uint8_t *bytes, lldb::addr_t process_address,
 625                              size_t size, Status &error) {
 626   error.Clear();
 627
 628   AllocationMap::iterator iter = FindAllocation(process_address, size);
 629
 630   if (iter == m_allocations.end()) {
 631     lldb::ProcessSP process_sp = m_process_wp.lock();
 632
 633     if (process_sp) {
 634       process_sp->ReadMemory(process_address, bytes, size, error);
 635       return;
 636     }
 637
 638     lldb::TargetSP target_sp = m_target_wp.lock();
 639
 640     if (target_sp) {
 641       Address absolute_address(process_address);
 642       target_sp->ReadMemory(absolute_address, false, bytes, size, error);
 643       return;
 644     }
 645
 646     error.SetErrorToGenericError();
 647     error.SetErrorString("Couldn't read: no allocation contains the target "
 648                          "range, and neither the process nor the target exist");
 649     return;
 650   }
 651
 652   Allocation &allocation = iter->second;
 653
 654   uint64_t offset = process_address - allocation.m_process_start;
 655
 656   if (offset > allocation.m_size) {
 657     error.SetErrorToGenericError();
 658     error.SetErrorString("Couldn't read: data is not in the allocation");
 659     return;
 660   }
 661
 662   lldb::ProcessSP process_sp;
 663
 664   switch (allocation.m_policy) {
 665   default:
 666     error.SetErrorToGenericError();
 667     error.SetErrorString("Couldn't read: invalid allocation policy");
 668     return;
 669   case eAllocationPolicyHostOnly:
 670     if (!allocation.m_data.GetByteSize()) {
 671       error.SetErrorToGenericError();
 672       error.SetErrorString("Couldn't read: data buffer is empty");
 673       return;
 674     }
 675     if (allocation.m_data.GetByteSize() < offset + size) {
 676       error.SetErrorToGenericError();
 677       error.SetErrorString("Couldn't read: not enough underlying data");
 678       return;
 679     }
 680
 681     ::memcpy(bytes, allocation.m_data.GetBytes() + offset, size);
 682     break;
 683   case eAllocationPolicyMirror:
 684     process_sp = m_process_wp.lock();
 685     if (process_sp) {
 686       process_sp->ReadMemory(process_address, bytes, size, error);
 687       if (!error.Success())
 688         return;
 689     } else {
 690       if (!allocation.m_data.GetByteSize()) {
 691         error.SetErrorToGenericError();
 692         error.SetErrorString("Couldn't read: data buffer is empty");
 693         return;
 694       }
 695       ::memcpy(bytes, allocation.m_data.GetBytes() + offset, size);
 696     }
 697     break;
 698   case eAllocationPolicyProcessOnly:
 699     process_sp = m_process_wp.lock();
 700     if (process_sp) {
 701       process_sp->ReadMemory(process_address, bytes, size, error);
 702       if (!error.Success())
 703         return;
 704     }
 705     break;
 706   }
 707
 708   if (lldb_private::Log *log =
 709           lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
 710     LLDB_LOGF(log,
 711               "IRMemoryMap::ReadMemory (0x%" PRIx64 ", 0x%" PRIx64
 712               ", 0x%" PRId64 ") came from [0x%" PRIx64 "..0x%" PRIx64 ")",
 713               (uint64_t)process_address, (uint64_t)bytes, (uint64_t)size,
 714               (uint64_t)allocation.m_process_start,
 715               (uint64_t)allocation.m_process_start +
 716                   (uint64_t)allocation.m_size);
 717   }
 718 }
 719
 720 void IRMemoryMap::ReadScalarFromMemory(Scalar &scalar,
 721                                        lldb::addr_t process_address,
 722                                        size_t size, Status &error) {
 723   error.Clear();
 724
 725   if (size > 0) {
 726     DataBufferHeap buf(size, 0);
 727     ReadMemory(buf.GetBytes(), process_address, size, error);
 728
 729     if (!error.Success())
 730       return;
 731
 732     DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(),
 733                             GetAddressByteSize());
 734
 735     lldb::offset_t offset = 0;
 736
 737     switch (size) {
 738     default:
 739       error.SetErrorToGenericError();
 740       error.SetErrorStringWithFormat(
 741           "Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
 742       return;
 743     case 1:
 744       scalar = extractor.GetU8(&offset);
 745       break;
 746     case 2:
 747       scalar = extractor.GetU16(&offset);
 748       break;
 749     case 4:
 750       scalar = extractor.GetU32(&offset);
 751       break;
 752     case 8:
 753       scalar = extractor.GetU64(&offset);
 754       break;
 755     }
 756   } else {
 757     error.SetErrorToGenericError();
 758     error.SetErrorString("Couldn't read scalar: its size was zero");
 759   }
 760   return;
 761 }
 762
 763 void IRMemoryMap::ReadPointerFromMemory(lldb::addr_t *address,
 764                                         lldb::addr_t process_address,
 765                                         Status &error) {
 766   error.Clear();
 767
 768   Scalar pointer_scalar;
 769   ReadScalarFromMemory(pointer_scalar, process_address, GetAddressByteSize(),
 770                        error);
 771
 772   if (!error.Success())
 773     return;
 774
 775   *address = pointer_scalar.ULongLong();
 776
 777   return;
 778 }
 779
 780 void IRMemoryMap::GetMemoryData(DataExtractor &extractor,
 781                                 lldb::addr_t process_address, size_t size,
 782                                 Status &error) {
 783   error.Clear();
 784
 785   if (size > 0) {
 786     AllocationMap::iterator iter = FindAllocation(process_address, size);
 787
 788     if (iter == m_allocations.end()) {
 789       error.SetErrorToGenericError();
 790       error.SetErrorStringWithFormat(
 791           "Couldn't find an allocation containing [0x%" PRIx64 "..0x%" PRIx64
 792           ")",
 793           process_address, process_address + size);
 794       return;
 795     }
 796
 797     Allocation &allocation = iter->second;
 798
 799     switch (allocation.m_policy) {
 800     default:
 801       error.SetErrorToGenericError();
 802       error.SetErrorString(
 803           "Couldn't get memory data: invalid allocation policy");
 804       return;
 805     case eAllocationPolicyProcessOnly:
 806       error.SetErrorToGenericError();
 807       error.SetErrorString(
 808           "Couldn't get memory data: memory is only in the target");
 809       return;
 810     case eAllocationPolicyMirror: {
 811       lldb::ProcessSP process_sp = m_process_wp.lock();
 812
 813       if (!allocation.m_data.GetByteSize()) {
 814         error.SetErrorToGenericError();
 815         error.SetErrorString("Couldn't get memory data: data buffer is empty");
 816         return;
 817       }
 818       if (process_sp) {
 819         process_sp->ReadMemory(allocation.m_process_start,
 820                                allocation.m_data.GetBytes(),
 821                                allocation.m_data.GetByteSize(), error);
 822         if (!error.Success())
 823           return;
 824         uint64_t offset = process_address - allocation.m_process_start;
 825         extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size,
 826                                   GetByteOrder(), GetAddressByteSize());
 827         return;
 828       }
 829     } break;
 830     case eAllocationPolicyHostOnly:
 831       if (!allocation.m_data.GetByteSize()) {
 832         error.SetErrorToGenericError();
 833         error.SetErrorString("Couldn't get memory data: data buffer is empty");
 834         return;
 835       }
 836       uint64_t offset = process_address - allocation.m_process_start;
 837       extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size,
 838                                 GetByteOrder(), GetAddressByteSize());
 839       return;
 840     }
 841   } else {
 842     error.SetErrorToGenericError();
 843     error.SetErrorString("Couldn't get memory data: its size was zero");
 844     return;
 845   }
 846 }