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