LLDB  mainline
IRMemoryMap.cpp
Go to the documentation of this file.
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 
11 #include "lldb/Target/Process.h"
12 #include "lldb/Target/Target.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 
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 
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 
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
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 
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 
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 
239 }
240 
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 
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 
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");
281  m_data.SetByteSize(size);
282  break;
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(
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;
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;
329  process_sp = m_process_wp.lock();
330  LLDB_LOGF(log,
331  "IRMemoryMap::%s process_sp=0x%" PRIxPTR
332  ", process_sp->CanJIT()=%s, process_sp->IsAlive()=%s",
333  __FUNCTION__, reinterpret_cast<uintptr_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;
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;
410  policy_string = "eAllocationPolicyHostOnly";
411  break;
413  policy_string = "eAllocationPolicyProcessOnly";
414  break;
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:
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  }
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 =
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 
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;
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;
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;
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 =
579  LLDB_LOGF(log,
580  "IRMemoryMap::WriteMemory (0x%" PRIx64 ", 0x%" PRIxPTR
581  ", 0x%" PRId64 ") went to [0x%" PRIx64 "..0x%" PRIx64 ")",
582  (uint64_t)process_address, reinterpret_cast<uintptr_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 
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 
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;
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;
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;
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 =
710  LLDB_LOGF(log,
711  "IRMemoryMap::ReadMemory (0x%" PRIx64 ", 0x%" PRIxPTR
712  ", 0x%" PRId64 ") came from [0x%" PRIx64 "..0x%" PRIx64 ")",
713  (uint64_t)process_address, reinterpret_cast<uintptr_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 
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(),
734 
735  lldb::offset_t offset = 0;
736 
737  switch (size) {
738  default:
739  error.SetErrorToGenericError();
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 
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 
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();
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;
806  error.SetErrorToGenericError();
807  error.SetErrorString(
808  "Couldn't get memory data: memory is only in the target");
809  return;
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,
827  return;
828  }
829  } break;
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,
839  return;
840  }
841  } else {
842  error.SetErrorToGenericError();
843  error.SetErrorString("Couldn't get memory data: its size was zero");
844  return;
845  }
846 }
lldb::ProcessWP m_process_wp
Definition: IRMemoryMap.h:116
void Free(lldb::addr_t process_address, Status &error)
An data extractor class.
Definition: DataExtractor.h:46
A class that represents a running process on the host machine.
size_t GetByteSize() const
Definition: Scalar.cpp:184
AllocationMap::iterator FindAllocation(lldb::addr_t addr, size_t size)
#define lldbassert(x)
Definition: LLDBAssert.h:15
IRMemoryMap(lldb::TargetSP target_sp)
Definition: IRMemoryMap.cpp:22
void WritePointerToMemory(lldb::addr_t process_address, lldb::addr_t address, Status &error)
size_t GetAsMemoryData(void *dst, size_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
Definition: Scalar.cpp:2696
AllocationPolicy m_policy
Flags. Keep these grouped together to avoid structure padding.
Definition: IRMemoryMap.h:98
ExecutionContextScope * GetBestExecutionContextScope() const
void GetMemoryData(DataExtractor &extractor, lldb::addr_t process_address, size_t size, Status &error)
lldb::offset_t SetByteSize(lldb::offset_t byte_size)
Set the number of bytes in the data buffer.
void WriteMemory(lldb::addr_t process_address, const uint8_t *bytes, size_t size, Status &error)
bool GetAllocSize(lldb::addr_t address, size_t &size)
size_t m_size
The size of the requested allocation.
Definition: IRMemoryMap.h:94
A subclass of DataBuffer that stores a data buffer on the heap.
void ReadPointerFromMemory(lldb::addr_t *address, lldb::addr_t process_address, Status &error)
The intent is that this allocation exist only in the process.
Definition: IRMemoryMap.h:49
This allocation was created in the host and will never make it into the process.
Definition: IRMemoryMap.h:42
bool IntersectsAllocation(lldb::addr_t addr, size_t size) const
#define UINT32_MAX
Definition: lldb-defines.h:31
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
void ReadScalarFromMemory(Scalar &scalar, lldb::addr_t process_address, size_t size, Status &error)
lldb::TargetWP m_target_wp
Definition: IRMemoryMap.h:119
lldb::addr_t m_process_start
The base address of the allocation in the process.
Definition: IRMemoryMap.h:93
Allocation(lldb::addr_t process_alloc, lldb::addr_t process_start, size_t size, uint32_t permissions, uint8_t alignment, AllocationPolicy m_policy)
void SetErrorToGenericError()
Set the current error to a generic error.
Definition: Status.cpp:232
uint64_t offset_t
Definition: lldb-types.h:87
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
void Leak(lldb::addr_t process_address, Status &error)
The intent is that this allocation exist both in the host and the process and have the same content i...
Definition: IRMemoryMap.h:46
void Clear()
Clear the object state.
Definition: Status.cpp:168
ByteOrder
Byte ordering definitions.
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:1611
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:242
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
bool Success() const
Test for success condition.
Definition: Status.cpp:288
A section + offset based address class.
Definition: Address.h:59
void WriteScalarToMemory(lldb::addr_t process_address, Scalar &scalar, size_t size, Status &error)
#define LLDB_LOGF(log,...)
Definition: Log.h:249
uint64_t addr_t
Definition: lldb-types.h:83
static bool AllocationsIntersect(lldb::addr_t addr1, size_t size1, lldb::addr_t addr2, size_t size2)
bool Fail() const
Test for error condition.
Definition: Status.cpp:182
lldb::addr_t FindSpace(size_t size)
Definition: IRMemoryMap.cpp:45
uint8_t * GetBytes() override
lldb::addr_t Malloc(size_t size, uint8_t alignment, uint32_t permissions, AllocationPolicy policy, bool zero_memory, Status &error)
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:256
#define LIBLLDB_LOG_EXPRESSIONS
Definition: Logging.h:22
lldb::ByteOrder GetByteOrder()
lldb::offset_t GetByteSize() const override
lldb::addr_t m_process_alloc
The (unaligned) base for the remote allocation.
Definition: IRMemoryMap.h:91
AllocationMap m_allocations
Definition: IRMemoryMap.h:121
void ReadMemory(uint8_t *bytes, lldb::addr_t process_address, size_t size, Status &error)
An error handling class.
Definition: Status.h:44