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/Target/MemoryRegionInfo.h"
12 #include "lldb/Target/Process.h"
13 #include "lldb/Target/Target.h"
14 #include "lldb/Utility/DataBufferHeap.h"
15 #include "lldb/Utility/DataExtractor.h"
16 #include "lldb/Utility/LLDBAssert.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
IRMemoryMap(lldb::TargetSP target_sp)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
~IRMemoryMap()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
FindSpace(size_t size)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 // 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 has
97 // 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 Status 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(0 && "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
FindAllocation(lldb::addr_t addr,size_t size)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
IntersectsAllocation(lldb::addr_t addr,size_t size) const184 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 equal to where the given interval begins, it's possible that the
192 // given interval intersects either the returned interval or the previous
193 // interval. Thus, we need to check both. Note that we only need to check
194 // these two intervals. Since all intervals are disjoint it is not possible
195 // that an adjacent interval does not intersect, but a non-adjacent interval
196 // does intersect.
197 if (iter != m_allocations.end()) {
198 if (AllocationsIntersect(addr, size, iter->second.m_process_start,
199 iter->second.m_size))
200 return true;
201 }
202
203 if (iter != m_allocations.begin()) {
204 --iter;
205 if (AllocationsIntersect(addr, size, iter->second.m_process_start,
206 iter->second.m_size))
207 return true;
208 }
209
210 return false;
211 }
212
AllocationsIntersect(lldb::addr_t addr1,size_t size1,lldb::addr_t addr2,size_t size2)213 bool IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1,
214 lldb::addr_t addr2, size_t size2) {
215 // Given two half open intervals [A, B) and [X, Y), the only 6 permutations
216 // that satisfy A<B and X<Y are the following:
217 // A B X Y
218 // A X B Y (intersects)
219 // A X Y B (intersects)
220 // X A B Y (intersects)
221 // X A Y B (intersects)
222 // X Y A B
223 // The first is B <= X, and the last is Y <= A. So the condition is !(B <= X
224 // || Y <= A)), or (X < B && A < Y)
225 return (addr2 < (addr1 + size1)) && (addr1 < (addr2 + size2));
226 }
227
GetByteOrder()228 lldb::ByteOrder IRMemoryMap::GetByteOrder() {
229 lldb::ProcessSP process_sp = m_process_wp.lock();
230
231 if (process_sp)
232 return process_sp->GetByteOrder();
233
234 lldb::TargetSP target_sp = m_target_wp.lock();
235
236 if (target_sp)
237 return target_sp->GetArchitecture().GetByteOrder();
238
239 return lldb::eByteOrderInvalid;
240 }
241
GetAddressByteSize()242 uint32_t IRMemoryMap::GetAddressByteSize() {
243 lldb::ProcessSP process_sp = m_process_wp.lock();
244
245 if (process_sp)
246 return process_sp->GetAddressByteSize();
247
248 lldb::TargetSP target_sp = m_target_wp.lock();
249
250 if (target_sp)
251 return target_sp->GetArchitecture().GetAddressByteSize();
252
253 return UINT32_MAX;
254 }
255
GetBestExecutionContextScope() const256 ExecutionContextScope *IRMemoryMap::GetBestExecutionContextScope() const {
257 lldb::ProcessSP process_sp = m_process_wp.lock();
258
259 if (process_sp)
260 return process_sp.get();
261
262 lldb::TargetSP target_sp = m_target_wp.lock();
263
264 if (target_sp)
265 return target_sp.get();
266
267 return NULL;
268 }
269
Allocation(lldb::addr_t process_alloc,lldb::addr_t process_start,size_t size,uint32_t permissions,uint8_t alignment,AllocationPolicy policy)270 IRMemoryMap::Allocation::Allocation(lldb::addr_t process_alloc,
271 lldb::addr_t process_start, size_t size,
272 uint32_t permissions, uint8_t alignment,
273 AllocationPolicy policy)
274 : m_process_alloc(process_alloc), m_process_start(process_start),
275 m_size(size), m_policy(policy), m_leak(false), m_permissions(permissions),
276 m_alignment(alignment) {
277 switch (policy) {
278 default:
279 assert(0 && "We cannot reach this!");
280 case eAllocationPolicyHostOnly:
281 case eAllocationPolicyMirror:
282 m_data.SetByteSize(size);
283 break;
284 case eAllocationPolicyProcessOnly:
285 break;
286 }
287 }
288
Malloc(size_t size,uint8_t alignment,uint32_t permissions,AllocationPolicy policy,bool zero_memory,Status & error)289 lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
290 uint32_t permissions, AllocationPolicy policy,
291 bool zero_memory, Status &error) {
292 lldb_private::Log *log(
293 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
294 error.Clear();
295
296 lldb::ProcessSP process_sp;
297 lldb::addr_t allocation_address = LLDB_INVALID_ADDRESS;
298 lldb::addr_t aligned_address = LLDB_INVALID_ADDRESS;
299
300 size_t allocation_size;
301
302 if (size == 0) {
303 // FIXME: Malloc(0) should either return an invalid address or assert, in
304 // order to cut down on unnecessary allocations.
305 allocation_size = alignment;
306 } else {
307 // Round up the requested size to an aligned value.
308 allocation_size = llvm::alignTo(size, alignment);
309
310 // The process page cache does not see the requested alignment. We can't
311 // assume its result will be any more than 1-byte aligned. To work around
312 // this, request `alignment - 1` additional bytes.
313 allocation_size += alignment - 1;
314 }
315
316 switch (policy) {
317 default:
318 error.SetErrorToGenericError();
319 error.SetErrorString("Couldn't malloc: invalid allocation policy");
320 return LLDB_INVALID_ADDRESS;
321 case eAllocationPolicyHostOnly:
322 allocation_address = FindSpace(allocation_size);
323 if (allocation_address == LLDB_INVALID_ADDRESS) {
324 error.SetErrorToGenericError();
325 error.SetErrorString("Couldn't malloc: address space is full");
326 return LLDB_INVALID_ADDRESS;
327 }
328 break;
329 case eAllocationPolicyMirror:
330 process_sp = m_process_wp.lock();
331 if (log)
332 log->Printf("IRMemoryMap::%s process_sp=0x%" PRIx64
333 ", process_sp->CanJIT()=%s, process_sp->IsAlive()=%s",
334 __FUNCTION__, (lldb::addr_t)process_sp.get(),
335 process_sp && process_sp->CanJIT() ? "true" : "false",
336 process_sp && process_sp->IsAlive() ? "true" : "false");
337 if (process_sp && process_sp->CanJIT() && process_sp->IsAlive()) {
338 if (!zero_memory)
339 allocation_address =
340 process_sp->AllocateMemory(allocation_size, permissions, error);
341 else
342 allocation_address =
343 process_sp->CallocateMemory(allocation_size, permissions, error);
344
345 if (!error.Success())
346 return LLDB_INVALID_ADDRESS;
347 } else {
348 if (log)
349 log->Printf("IRMemoryMap::%s switching to eAllocationPolicyHostOnly "
350 "due to failed condition (see previous expr log message)",
351 __FUNCTION__);
352 policy = eAllocationPolicyHostOnly;
353 allocation_address = FindSpace(allocation_size);
354 if (allocation_address == LLDB_INVALID_ADDRESS) {
355 error.SetErrorToGenericError();
356 error.SetErrorString("Couldn't malloc: address space is full");
357 return LLDB_INVALID_ADDRESS;
358 }
359 }
360 break;
361 case eAllocationPolicyProcessOnly:
362 process_sp = m_process_wp.lock();
363 if (process_sp) {
364 if (process_sp->CanJIT() && process_sp->IsAlive()) {
365 if (!zero_memory)
366 allocation_address =
367 process_sp->AllocateMemory(allocation_size, permissions, error);
368 else
369 allocation_address =
370 process_sp->CallocateMemory(allocation_size, permissions, error);
371
372 if (!error.Success())
373 return LLDB_INVALID_ADDRESS;
374 } else {
375 error.SetErrorToGenericError();
376 error.SetErrorString(
377 "Couldn't malloc: process doesn't support allocating memory");
378 return LLDB_INVALID_ADDRESS;
379 }
380 } else {
381 error.SetErrorToGenericError();
382 error.SetErrorString("Couldn't malloc: process doesn't exist, and this "
383 "memory must be in the process");
384 return LLDB_INVALID_ADDRESS;
385 }
386 break;
387 }
388
389 lldb::addr_t mask = alignment - 1;
390 aligned_address = (allocation_address + mask) & (~mask);
391
392 m_allocations.emplace(
393 std::piecewise_construct, std::forward_as_tuple(aligned_address),
394 std::forward_as_tuple(allocation_address, aligned_address,
395 allocation_size, permissions, alignment, policy));
396
397 if (zero_memory) {
398 Status write_error;
399 std::vector<uint8_t> zero_buf(size, 0);
400 WriteMemory(aligned_address, zero_buf.data(), size, write_error);
401 }
402
403 if (log) {
404 const char *policy_string;
405
406 switch (policy) {
407 default:
408 policy_string = "<invalid policy>";
409 break;
410 case eAllocationPolicyHostOnly:
411 policy_string = "eAllocationPolicyHostOnly";
412 break;
413 case eAllocationPolicyProcessOnly:
414 policy_string = "eAllocationPolicyProcessOnly";
415 break;
416 case eAllocationPolicyMirror:
417 policy_string = "eAllocationPolicyMirror";
418 break;
419 }
420
421 log->Printf("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
Leak(lldb::addr_t process_address,Status & error)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
Free(lldb::addr_t process_address,Status & error)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 log->Printf("IRMemoryMap::Free (0x%" PRIx64 ") freed [0x%" PRIx64
482 "..0x%" PRIx64 ")",
483 (uint64_t)process_address, iter->second.m_process_start,
484 iter->second.m_process_start + iter->second.m_size);
485 }
486
487 m_allocations.erase(iter);
488 }
489
GetAllocSize(lldb::addr_t address,size_t & size)490 bool IRMemoryMap::GetAllocSize(lldb::addr_t address, size_t &size) {
491 AllocationMap::iterator iter = FindAllocation(address, size);
492 if (iter == m_allocations.end())
493 return false;
494
495 Allocation &al = iter->second;
496
497 if (address > (al.m_process_start + al.m_size)) {
498 size = 0;
499 return false;
500 }
501
502 if (address > al.m_process_start) {
503 int dif = address - al.m_process_start;
504 size = al.m_size - dif;
505 return true;
506 }
507
508 size = al.m_size;
509 return true;
510 }
511
WriteMemory(lldb::addr_t process_address,const uint8_t * bytes,size_t size,Status & error)512 void IRMemoryMap::WriteMemory(lldb::addr_t process_address,
513 const uint8_t *bytes, size_t size,
514 Status &error) {
515 error.Clear();
516
517 AllocationMap::iterator iter = FindAllocation(process_address, size);
518
519 if (iter == m_allocations.end()) {
520 lldb::ProcessSP process_sp = m_process_wp.lock();
521
522 if (process_sp) {
523 process_sp->WriteMemory(process_address, bytes, size, error);
524 return;
525 }
526
527 error.SetErrorToGenericError();
528 error.SetErrorString("Couldn't write: no allocation contains the target "
529 "range and the process doesn't exist");
530 return;
531 }
532
533 Allocation &allocation = iter->second;
534
535 uint64_t offset = process_address - allocation.m_process_start;
536
537 lldb::ProcessSP process_sp;
538
539 switch (allocation.m_policy) {
540 default:
541 error.SetErrorToGenericError();
542 error.SetErrorString("Couldn't write: invalid allocation policy");
543 return;
544 case eAllocationPolicyHostOnly:
545 if (!allocation.m_data.GetByteSize()) {
546 error.SetErrorToGenericError();
547 error.SetErrorString("Couldn't write: data buffer is empty");
548 return;
549 }
550 ::memcpy(allocation.m_data.GetBytes() + offset, bytes, size);
551 break;
552 case eAllocationPolicyMirror:
553 if (!allocation.m_data.GetByteSize()) {
554 error.SetErrorToGenericError();
555 error.SetErrorString("Couldn't write: data buffer is empty");
556 return;
557 }
558 ::memcpy(allocation.m_data.GetBytes() + offset, bytes, size);
559 process_sp = m_process_wp.lock();
560 if (process_sp) {
561 process_sp->WriteMemory(process_address, bytes, size, error);
562 if (!error.Success())
563 return;
564 }
565 break;
566 case eAllocationPolicyProcessOnly:
567 process_sp = m_process_wp.lock();
568 if (process_sp) {
569 process_sp->WriteMemory(process_address, bytes, size, error);
570 if (!error.Success())
571 return;
572 }
573 break;
574 }
575
576 if (lldb_private::Log *log =
577 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
578 log->Printf("IRMemoryMap::WriteMemory (0x%" PRIx64 ", 0x%" PRIx64
579 ", 0x%" PRId64 ") went to [0x%" PRIx64 "..0x%" PRIx64 ")",
580 (uint64_t)process_address, (uint64_t)bytes, (uint64_t)size,
581 (uint64_t)allocation.m_process_start,
582 (uint64_t)allocation.m_process_start +
583 (uint64_t)allocation.m_size);
584 }
585 }
586
WriteScalarToMemory(lldb::addr_t process_address,Scalar & scalar,size_t size,Status & error)587 void IRMemoryMap::WriteScalarToMemory(lldb::addr_t process_address,
588 Scalar &scalar, size_t size,
589 Status &error) {
590 error.Clear();
591
592 if (size == UINT32_MAX)
593 size = scalar.GetByteSize();
594
595 if (size > 0) {
596 uint8_t buf[32];
597 const size_t mem_size =
598 scalar.GetAsMemoryData(buf, size, GetByteOrder(), error);
599 if (mem_size > 0) {
600 return WriteMemory(process_address, buf, mem_size, error);
601 } else {
602 error.SetErrorToGenericError();
603 error.SetErrorString(
604 "Couldn't write scalar: failed to get scalar as memory data");
605 }
606 } else {
607 error.SetErrorToGenericError();
608 error.SetErrorString("Couldn't write scalar: its size was zero");
609 }
610 return;
611 }
612
WritePointerToMemory(lldb::addr_t process_address,lldb::addr_t address,Status & error)613 void IRMemoryMap::WritePointerToMemory(lldb::addr_t process_address,
614 lldb::addr_t address, Status &error) {
615 error.Clear();
616
617 Scalar scalar(address);
618
619 WriteScalarToMemory(process_address, scalar, GetAddressByteSize(), error);
620 }
621
ReadMemory(uint8_t * bytes,lldb::addr_t process_address,size_t size,Status & error)622 void IRMemoryMap::ReadMemory(uint8_t *bytes, lldb::addr_t process_address,
623 size_t size, Status &error) {
624 error.Clear();
625
626 AllocationMap::iterator iter = FindAllocation(process_address, size);
627
628 if (iter == m_allocations.end()) {
629 lldb::ProcessSP process_sp = m_process_wp.lock();
630
631 if (process_sp) {
632 process_sp->ReadMemory(process_address, bytes, size, error);
633 return;
634 }
635
636 lldb::TargetSP target_sp = m_target_wp.lock();
637
638 if (target_sp) {
639 Address absolute_address(process_address);
640 target_sp->ReadMemory(absolute_address, false, bytes, size, error);
641 return;
642 }
643
644 error.SetErrorToGenericError();
645 error.SetErrorString("Couldn't read: no allocation contains the target "
646 "range, and neither the process nor the target exist");
647 return;
648 }
649
650 Allocation &allocation = iter->second;
651
652 uint64_t offset = process_address - allocation.m_process_start;
653
654 if (offset > allocation.m_size) {
655 error.SetErrorToGenericError();
656 error.SetErrorString("Couldn't read: data is not in the allocation");
657 return;
658 }
659
660 lldb::ProcessSP process_sp;
661
662 switch (allocation.m_policy) {
663 default:
664 error.SetErrorToGenericError();
665 error.SetErrorString("Couldn't read: invalid allocation policy");
666 return;
667 case eAllocationPolicyHostOnly:
668 if (!allocation.m_data.GetByteSize()) {
669 error.SetErrorToGenericError();
670 error.SetErrorString("Couldn't read: data buffer is empty");
671 return;
672 }
673 if (allocation.m_data.GetByteSize() < offset + size) {
674 error.SetErrorToGenericError();
675 error.SetErrorString("Couldn't read: not enough underlying data");
676 return;
677 }
678
679 ::memcpy(bytes, allocation.m_data.GetBytes() + offset, size);
680 break;
681 case eAllocationPolicyMirror:
682 process_sp = m_process_wp.lock();
683 if (process_sp) {
684 process_sp->ReadMemory(process_address, bytes, size, error);
685 if (!error.Success())
686 return;
687 } else {
688 if (!allocation.m_data.GetByteSize()) {
689 error.SetErrorToGenericError();
690 error.SetErrorString("Couldn't read: data buffer is empty");
691 return;
692 }
693 ::memcpy(bytes, allocation.m_data.GetBytes() + offset, size);
694 }
695 break;
696 case eAllocationPolicyProcessOnly:
697 process_sp = m_process_wp.lock();
698 if (process_sp) {
699 process_sp->ReadMemory(process_address, bytes, size, error);
700 if (!error.Success())
701 return;
702 }
703 break;
704 }
705
706 if (lldb_private::Log *log =
707 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
708 log->Printf("IRMemoryMap::ReadMemory (0x%" PRIx64 ", 0x%" PRIx64
709 ", 0x%" PRId64 ") came from [0x%" PRIx64 "..0x%" PRIx64 ")",
710 (uint64_t)process_address, (uint64_t)bytes, (uint64_t)size,
711 (uint64_t)allocation.m_process_start,
712 (uint64_t)allocation.m_process_start +
713 (uint64_t)allocation.m_size);
714 }
715 }
716
ReadScalarFromMemory(Scalar & scalar,lldb::addr_t process_address,size_t size,Status & error)717 void IRMemoryMap::ReadScalarFromMemory(Scalar &scalar,
718 lldb::addr_t process_address,
719 size_t size, Status &error) {
720 error.Clear();
721
722 if (size > 0) {
723 DataBufferHeap buf(size, 0);
724 ReadMemory(buf.GetBytes(), process_address, size, error);
725
726 if (!error.Success())
727 return;
728
729 DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(),
730 GetAddressByteSize());
731
732 lldb::offset_t offset = 0;
733
734 switch (size) {
735 default:
736 error.SetErrorToGenericError();
737 error.SetErrorStringWithFormat(
738 "Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
739 return;
740 case 1:
741 scalar = extractor.GetU8(&offset);
742 break;
743 case 2:
744 scalar = extractor.GetU16(&offset);
745 break;
746 case 4:
747 scalar = extractor.GetU32(&offset);
748 break;
749 case 8:
750 scalar = extractor.GetU64(&offset);
751 break;
752 }
753 } else {
754 error.SetErrorToGenericError();
755 error.SetErrorString("Couldn't read scalar: its size was zero");
756 }
757 return;
758 }
759
ReadPointerFromMemory(lldb::addr_t * address,lldb::addr_t process_address,Status & error)760 void IRMemoryMap::ReadPointerFromMemory(lldb::addr_t *address,
761 lldb::addr_t process_address,
762 Status &error) {
763 error.Clear();
764
765 Scalar pointer_scalar;
766 ReadScalarFromMemory(pointer_scalar, process_address, GetAddressByteSize(),
767 error);
768
769 if (!error.Success())
770 return;
771
772 *address = pointer_scalar.ULongLong();
773
774 return;
775 }
776
GetMemoryData(DataExtractor & extractor,lldb::addr_t process_address,size_t size,Status & error)777 void IRMemoryMap::GetMemoryData(DataExtractor &extractor,
778 lldb::addr_t process_address, size_t size,
779 Status &error) {
780 error.Clear();
781
782 if (size > 0) {
783 AllocationMap::iterator iter = FindAllocation(process_address, size);
784
785 if (iter == m_allocations.end()) {
786 error.SetErrorToGenericError();
787 error.SetErrorStringWithFormat(
788 "Couldn't find an allocation containing [0x%" PRIx64 "..0x%" PRIx64
789 ")",
790 process_address, process_address + size);
791 return;
792 }
793
794 Allocation &allocation = iter->second;
795
796 switch (allocation.m_policy) {
797 default:
798 error.SetErrorToGenericError();
799 error.SetErrorString(
800 "Couldn't get memory data: invalid allocation policy");
801 return;
802 case eAllocationPolicyProcessOnly:
803 error.SetErrorToGenericError();
804 error.SetErrorString(
805 "Couldn't get memory data: memory is only in the target");
806 return;
807 case eAllocationPolicyMirror: {
808 lldb::ProcessSP process_sp = m_process_wp.lock();
809
810 if (!allocation.m_data.GetByteSize()) {
811 error.SetErrorToGenericError();
812 error.SetErrorString("Couldn't get memory data: data buffer is empty");
813 return;
814 }
815 if (process_sp) {
816 process_sp->ReadMemory(allocation.m_process_start,
817 allocation.m_data.GetBytes(),
818 allocation.m_data.GetByteSize(), error);
819 if (!error.Success())
820 return;
821 uint64_t offset = process_address - allocation.m_process_start;
822 extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size,
823 GetByteOrder(), GetAddressByteSize());
824 return;
825 }
826 } break;
827 case eAllocationPolicyHostOnly:
828 if (!allocation.m_data.GetByteSize()) {
829 error.SetErrorToGenericError();
830 error.SetErrorString("Couldn't get memory data: data buffer is empty");
831 return;
832 }
833 uint64_t offset = process_address - allocation.m_process_start;
834 extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size,
835 GetByteOrder(), GetAddressByteSize());
836 return;
837 }
838 } else {
839 error.SetErrorToGenericError();
840 error.SetErrorString("Couldn't get memory data: its size was zero");
841 return;
842 }
843 }
844