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