lldb/source/Expression/IRMemoryMap.cpp

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