contrib/llvm/tools/lldb/source/Expression/IRMemoryMap.cpp

   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/Core/DataBufferHeap.h"
  11 #include "lldb/Core/DataExtractor.h"
  12 #include "lldb/Core/Error.h"
  13 #include "lldb/Core/Log.h"
  14 #include "lldb/Core/Scalar.h"
  15 #include "lldb/Expression/IRMemoryMap.h"
  16 #include "lldb/Target/Process.h"
  17 #include "lldb/Target/Target.h"
  18
  19 using namespace lldb_private;
  20
  21 IRMemoryMap::IRMemoryMap (lldb::TargetSP target_sp) :
  22     m_target_wp(target_sp)
  23 {
  24     if (target_sp)
  25         m_process_wp = target_sp->GetProcessSP();
  26 }
  27
  28 IRMemoryMap::~IRMemoryMap ()
  29 {
  30     lldb::ProcessSP process_sp = m_process_wp.lock();
  31
  32     if (process_sp)
  33     {
  34         AllocationMap::iterator iter;
  35
  36         Error err;
  37
  38         while ((iter = m_allocations.begin()) != m_allocations.end())
  39         {
  40             err.Clear();
  41             if (iter->second.m_leak)
  42                 m_allocations.erase(iter);
  43             else
  44                 Free(iter->first, err);
  45         }
  46     }
  47 }
  48
  49 lldb::addr_t
  50 IRMemoryMap::FindSpace (size_t size)
  51 {
  52     lldb::TargetSP target_sp = m_target_wp.lock();
  53     lldb::ProcessSP process_sp = m_process_wp.lock();
  54
  55     lldb::addr_t ret = LLDB_INVALID_ADDRESS;
  56
  57     if (process_sp && process_sp->CanJIT() && process_sp->IsAlive())
  58     {
  59         Error alloc_error;
  60
  61         ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable | lldb::ePermissionsWritable, alloc_error);
  62
  63         if (!alloc_error.Success())
  64             return LLDB_INVALID_ADDRESS;
  65         else
  66             return ret;
  67     }
  68
  69     for (int iterations = 0; iterations < 16; ++iterations)
  70     {
  71         lldb::addr_t candidate = LLDB_INVALID_ADDRESS;
  72
  73         switch (target_sp->GetArchitecture().GetAddressByteSize())
  74         {
  75         case 4:
  76             {
  77                 uint32_t random_data = random();
  78                 candidate = random_data;
  79                 candidate &= ~0xfffull;
  80                 break;
  81             }
  82         case 8:
  83             {
  84                 uint32_t random_low = random();
  85                 uint32_t random_high = random();
  86                 candidate = random_high;
  87                 candidate <<= 32ull;
  88                 candidate |= random_low;
  89                 candidate &= ~0xfffull;
  90                 break;
  91             }
  92         }
  93
  94         if (IntersectsAllocation(candidate, size))
  95             continue;
  96
  97         ret = candidate;
  98
  99         return ret;
 100     }
 101
 102     return ret;
 103 }
 104
 105 IRMemoryMap::AllocationMap::iterator
 106 IRMemoryMap::FindAllocation (lldb::addr_t addr, size_t size)
 107 {
 108     if (addr == LLDB_INVALID_ADDRESS)
 109         return m_allocations.end();
 110
 111     AllocationMap::iterator iter = m_allocations.lower_bound (addr);
 112
 113     if (iter == m_allocations.end() ||
 114         iter->first > addr)
 115     {
 116         if (iter == m_allocations.begin())
 117             return m_allocations.end();
 118         iter--;
 119     }
 120
 121     if (iter->first <= addr && iter->first + iter->second.m_size >= addr + size)
 122         return iter;
 123
 124     return m_allocations.end();
 125 }
 126
 127 bool
 128 IRMemoryMap::IntersectsAllocation (lldb::addr_t addr, size_t size)
 129 {
 130     if (addr == LLDB_INVALID_ADDRESS)
 131         return false;
 132
 133     AllocationMap::iterator iter = m_allocations.lower_bound (addr);
 134
 135     if (iter == m_allocations.end() ||
 136         iter->first > addr)
 137     {
 138         if (iter == m_allocations.begin())
 139             return false;
 140
 141         iter--;
 142     }
 143
 144     while (iter != m_allocations.end() && iter->second.m_process_alloc < addr + size)
 145     {
 146         if (iter->second.m_process_start + iter->second.m_size > addr)
 147             return true;
 148
 149         ++iter;
 150     }
 151
 152     return false;
 153 }
 154
 155 lldb::ByteOrder
 156 IRMemoryMap::GetByteOrder()
 157 {
 158     lldb::ProcessSP process_sp = m_process_wp.lock();
 159
 160     if (process_sp)
 161         return process_sp->GetByteOrder();
 162
 163     lldb::TargetSP target_sp = m_target_wp.lock();
 164
 165     if (target_sp)
 166         return target_sp->GetArchitecture().GetByteOrder();
 167
 168     return lldb::eByteOrderInvalid;
 169 }
 170
 171 uint32_t
 172 IRMemoryMap::GetAddressByteSize()
 173 {
 174     lldb::ProcessSP process_sp = m_process_wp.lock();
 175
 176     if (process_sp)
 177         return process_sp->GetAddressByteSize();
 178
 179     lldb::TargetSP target_sp = m_target_wp.lock();
 180
 181     if (target_sp)
 182         return target_sp->GetArchitecture().GetAddressByteSize();
 183
 184     return UINT32_MAX;
 185 }
 186
 187 ExecutionContextScope *
 188 IRMemoryMap::GetBestExecutionContextScope()
 189 {
 190     lldb::ProcessSP process_sp = m_process_wp.lock();
 191
 192     if (process_sp)
 193         return process_sp.get();
 194
 195     lldb::TargetSP target_sp = m_target_wp.lock();
 196
 197     if (target_sp)
 198         return target_sp.get();
 199
 200     return NULL;
 201 }
 202
 203 IRMemoryMap::Allocation::Allocation (lldb::addr_t process_alloc,
 204                                      lldb::addr_t process_start,
 205                                      size_t size,
 206                                      uint32_t permissions,
 207                                      uint8_t alignment,
 208                                      AllocationPolicy policy) :
 209     m_process_alloc (process_alloc),
 210     m_process_start (process_start),
 211     m_size (size),
 212     m_permissions (permissions),
 213     m_alignment (alignment),
 214     m_policy (policy),
 215     m_leak (false)
 216 {
 217     switch (policy)
 218     {
 219         default:
 220             assert (0 && "We cannot reach this!");
 221         case eAllocationPolicyHostOnly:
 222             m_data.SetByteSize(size);
 223             memset(m_data.GetBytes(), 0, size);
 224             break;
 225         case eAllocationPolicyProcessOnly:
 226             break;
 227         case eAllocationPolicyMirror:
 228             m_data.SetByteSize(size);
 229             memset(m_data.GetBytes(), 0, size);
 230             break;
 231     }
 232 }
 233
 234 lldb::addr_t
 235 IRMemoryMap::Malloc (size_t size, uint8_t alignment, uint32_t permissions, AllocationPolicy policy, Error &error)
 236 {
 237     error.Clear();
 238
 239     lldb::ProcessSP process_sp;
 240     lldb::addr_t    allocation_address  = LLDB_INVALID_ADDRESS;
 241     lldb::addr_t    aligned_address     = LLDB_INVALID_ADDRESS;
 242
 243     size_t          alignment_mask = alignment - 1;
 244     size_t          allocation_size;
 245
 246     if (size == 0)
 247         allocation_size = alignment;
 248     else
 249         allocation_size = (size & alignment_mask) ? ((size + alignment) & (~alignment_mask)) : size;
 250
 251     switch (policy)
 252     {
 253     default:
 254         error.SetErrorToGenericError();
 255         error.SetErrorString("Couldn't malloc: invalid allocation policy");
 256         return LLDB_INVALID_ADDRESS;
 257     case eAllocationPolicyHostOnly:
 258         allocation_address = FindSpace(allocation_size);
 259         if (allocation_address == LLDB_INVALID_ADDRESS)
 260         {
 261             error.SetErrorToGenericError();
 262             error.SetErrorString("Couldn't malloc: address space is full");
 263             return LLDB_INVALID_ADDRESS;
 264         }
 265         break;
 266     case eAllocationPolicyMirror:
 267         process_sp = m_process_wp.lock();
 268         if (process_sp && process_sp->CanJIT() && process_sp->IsAlive())
 269         {
 270             allocation_address = process_sp->AllocateMemory(allocation_size, permissions, error);
 271             if (!error.Success())
 272                 return LLDB_INVALID_ADDRESS;
 273         }
 274         else
 275         {
 276             policy = eAllocationPolicyHostOnly;
 277             allocation_address = FindSpace(allocation_size);
 278             if (allocation_address == LLDB_INVALID_ADDRESS)
 279             {
 280                 error.SetErrorToGenericError();
 281                 error.SetErrorString("Couldn't malloc: address space is full");
 282                 return LLDB_INVALID_ADDRESS;
 283             }
 284         }
 285         break;
 286     case eAllocationPolicyProcessOnly:
 287         process_sp = m_process_wp.lock();
 288         if (process_sp)
 289         {
 290             if (process_sp->CanJIT() && process_sp->IsAlive())
 291             {
 292                 allocation_address = process_sp->AllocateMemory(allocation_size, permissions, error);
 293                 if (!error.Success())
 294                     return LLDB_INVALID_ADDRESS;
 295             }
 296             else
 297             {
 298                 error.SetErrorToGenericError();
 299                 error.SetErrorString("Couldn't malloc: process doesn't support allocating memory");
 300                 return LLDB_INVALID_ADDRESS;
 301             }
 302         }
 303         else
 304         {
 305             error.SetErrorToGenericError();
 306             error.SetErrorString("Couldn't malloc: process doesn't exist, and this memory must be in the process");
 307             return LLDB_INVALID_ADDRESS;
 308         }
 309         break;
 310     }
 311
 312
 313     lldb::addr_t mask = alignment - 1;
 314     aligned_address = (allocation_address + mask) & (~mask);
 315
 316     m_allocations[aligned_address] = Allocation(allocation_address,
 317                                                 aligned_address,
 318                                                 allocation_size,
 319                                                 permissions,
 320                                                 alignment,
 321                                                 policy);
 322
 323     if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
 324     {
 325         const char * policy_string;
 326
 327         switch (policy)
 328         {
 329         default:
 330             policy_string = "<invalid policy>";
 331             break;
 332         case eAllocationPolicyHostOnly:
 333             policy_string = "eAllocationPolicyHostOnly";
 334             break;
 335         case eAllocationPolicyProcessOnly:
 336             policy_string = "eAllocationPolicyProcessOnly";
 337             break;
 338         case eAllocationPolicyMirror:
 339             policy_string = "eAllocationPolicyMirror";
 340             break;
 341         }
 342
 343         log->Printf("IRMemoryMap::Malloc (%" PRIu64 ", 0x%" PRIx64 ", 0x%" PRIx64 ", %s) -> 0x%" PRIx64,
 344                     (uint64_t)allocation_size,
 345                     (uint64_t)alignment,
 346                     (uint64_t)permissions,
 347                     policy_string,
 348                     aligned_address);
 349     }
 350
 351     return aligned_address;
 352 }
 353
 354 void
 355 IRMemoryMap::Leak (lldb::addr_t process_address, Error &error)
 356 {
 357     error.Clear();
 358
 359     AllocationMap::iterator iter = m_allocations.find(process_address);
 360
 361     if (iter == m_allocations.end())
 362     {
 363         error.SetErrorToGenericError();
 364         error.SetErrorString("Couldn't leak: allocation doesn't exist");
 365         return;
 366     }
 367
 368     Allocation &allocation = iter->second;
 369
 370     allocation.m_leak = true;
 371 }
 372
 373 void
 374 IRMemoryMap::Free (lldb::addr_t process_address, Error &error)
 375 {
 376     error.Clear();
 377
 378     AllocationMap::iterator iter = m_allocations.find(process_address);
 379
 380     if (iter == m_allocations.end())
 381     {
 382         error.SetErrorToGenericError();
 383         error.SetErrorString("Couldn't free: allocation doesn't exist");
 384         return;
 385     }
 386
 387     Allocation &allocation = iter->second;
 388
 389     switch (allocation.m_policy)
 390     {
 391     default:
 392     case eAllocationPolicyHostOnly:
 393         {
 394             lldb::ProcessSP process_sp = m_process_wp.lock();
 395             if (process_sp)
 396             {
 397                 if (process_sp->CanJIT() && process_sp->IsAlive())
 398                     process_sp->DeallocateMemory(allocation.m_process_alloc); // FindSpace allocated this for real
 399             }
 400
 401             break;
 402         }
 403     case eAllocationPolicyMirror:
 404     case eAllocationPolicyProcessOnly:
 405         {
 406             lldb::ProcessSP process_sp = m_process_wp.lock();
 407             if (process_sp)
 408                 process_sp->DeallocateMemory(allocation.m_process_alloc);
 409         }
 410     }
 411
 412     if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
 413     {
 414         log->Printf("IRMemoryMap::Free (0x%" PRIx64 ") freed [0x%" PRIx64 "..0x%" PRIx64 ")",
 415                     (uint64_t)process_address,
 416                     iter->second.m_process_start,
 417                     iter->second.m_process_start + iter->second.m_size);
 418     }
 419
 420     m_allocations.erase(iter);
 421 }
 422
 423 void
 424 IRMemoryMap::WriteMemory (lldb::addr_t process_address, const uint8_t *bytes, size_t size, Error &error)
 425 {
 426     error.Clear();
 427
 428     AllocationMap::iterator iter = FindAllocation(process_address, size);
 429
 430     if (iter == m_allocations.end())
 431     {
 432         lldb::ProcessSP process_sp = m_process_wp.lock();
 433
 434         if (process_sp)
 435         {
 436             process_sp->WriteMemory(process_address, bytes, size, error);
 437             return;
 438         }
 439
 440         error.SetErrorToGenericError();
 441         error.SetErrorString("Couldn't write: no allocation contains the target range and the process doesn't exist");
 442         return;
 443     }
 444
 445     Allocation &allocation = iter->second;
 446
 447     uint64_t offset = process_address - allocation.m_process_start;
 448
 449     lldb::ProcessSP process_sp;
 450
 451     switch (allocation.m_policy)
 452     {
 453     default:
 454         error.SetErrorToGenericError();
 455         error.SetErrorString("Couldn't write: invalid allocation policy");
 456         return;
 457     case eAllocationPolicyHostOnly:
 458         if (!allocation.m_data.GetByteSize())
 459         {
 460             error.SetErrorToGenericError();
 461             error.SetErrorString("Couldn't write: data buffer is empty");
 462             return;
 463         }
 464         ::memcpy (allocation.m_data.GetBytes() + offset, bytes, size);
 465         break;
 466     case eAllocationPolicyMirror:
 467         if (!allocation.m_data.GetByteSize())
 468         {
 469             error.SetErrorToGenericError();
 470             error.SetErrorString("Couldn't write: data buffer is empty");
 471             return;
 472         }
 473         ::memcpy (allocation.m_data.GetBytes() + offset, bytes, size);
 474         process_sp = m_process_wp.lock();
 475         if (process_sp)
 476         {
 477             process_sp->WriteMemory(process_address, bytes, size, error);
 478             if (!error.Success())
 479                 return;
 480         }
 481         break;
 482     case eAllocationPolicyProcessOnly:
 483         process_sp = m_process_wp.lock();
 484         if (process_sp)
 485         {
 486             process_sp->WriteMemory(process_address, bytes, size, error);
 487             if (!error.Success())
 488                 return;
 489         }
 490         break;
 491     }
 492
 493     if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
 494     {
 495         log->Printf("IRMemoryMap::WriteMemory (0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRId64 ") went to [0x%" PRIx64 "..0x%" PRIx64 ")",
 496                     (uint64_t)process_address,
 497                     (uint64_t)bytes,
 498                     (uint64_t)size,
 499                     (uint64_t)allocation.m_process_start,
 500                     (uint64_t)allocation.m_process_start + (uint64_t)allocation.m_size);
 501     }
 502 }
 503
 504 void
 505 IRMemoryMap::WriteScalarToMemory (lldb::addr_t process_address, Scalar &scalar, size_t size, Error &error)
 506 {
 507     error.Clear();
 508
 509     if (size == UINT32_MAX)
 510         size = scalar.GetByteSize();
 511
 512     if (size > 0)
 513     {
 514         uint8_t buf[32];
 515         const size_t mem_size = scalar.GetAsMemoryData (buf, size, GetByteOrder(), error);
 516         if (mem_size > 0)
 517         {
 518             return WriteMemory(process_address, buf, mem_size, error);
 519         }
 520         else
 521         {
 522             error.SetErrorToGenericError();
 523             error.SetErrorString ("Couldn't write scalar: failed to get scalar as memory data");
 524         }
 525     }
 526     else
 527     {
 528         error.SetErrorToGenericError();
 529         error.SetErrorString ("Couldn't write scalar: its size was zero");
 530     }
 531     return;
 532 }
 533
 534 void
 535 IRMemoryMap::WritePointerToMemory (lldb::addr_t process_address, lldb::addr_t address, Error &error)
 536 {
 537     error.Clear();
 538
 539     Scalar scalar(address);
 540
 541     WriteScalarToMemory(process_address, scalar, GetAddressByteSize(), error);
 542 }
 543
 544 void
 545 IRMemoryMap::ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t size, Error &error)
 546 {
 547     error.Clear();
 548
 549     AllocationMap::iterator iter = FindAllocation(process_address, size);
 550
 551     if (iter == m_allocations.end())
 552     {
 553         lldb::ProcessSP process_sp = m_process_wp.lock();
 554
 555         if (process_sp)
 556         {
 557             process_sp->ReadMemory(process_address, bytes, size, error);
 558             return;
 559         }
 560
 561         lldb::TargetSP target_sp = m_target_wp.lock();
 562
 563         if (target_sp)
 564         {
 565             Address absolute_address(process_address);
 566             target_sp->ReadMemory(absolute_address, false, bytes, size, error);
 567             return;
 568         }
 569
 570         error.SetErrorToGenericError();
 571         error.SetErrorString("Couldn't read: no allocation contains the target range, and neither the process nor the target exist");
 572         return;
 573     }
 574
 575     Allocation &allocation = iter->second;
 576
 577     uint64_t offset = process_address - allocation.m_process_start;
 578
 579     lldb::ProcessSP process_sp;
 580
 581     switch (allocation.m_policy)
 582     {
 583     default:
 584         error.SetErrorToGenericError();
 585         error.SetErrorString("Couldn't read: invalid allocation policy");
 586         return;
 587     case eAllocationPolicyHostOnly:
 588         if (!allocation.m_data.GetByteSize())
 589         {
 590             error.SetErrorToGenericError();
 591             error.SetErrorString("Couldn't read: data buffer is empty");
 592             return;
 593         }
 594         ::memcpy (bytes, allocation.m_data.GetBytes() + offset, size);
 595         break;
 596     case eAllocationPolicyMirror:
 597         process_sp = m_process_wp.lock();
 598         if (process_sp)
 599         {
 600             process_sp->ReadMemory(process_address, bytes, size, error);
 601             if (!error.Success())
 602                 return;
 603         }
 604         else
 605         {
 606             if (!allocation.m_data.GetByteSize())
 607             {
 608                 error.SetErrorToGenericError();
 609                 error.SetErrorString("Couldn't read: data buffer is empty");
 610                 return;
 611             }
 612             ::memcpy (bytes, allocation.m_data.GetBytes() + offset, size);
 613         }
 614         break;
 615     case eAllocationPolicyProcessOnly:
 616         process_sp = m_process_wp.lock();
 617         if (process_sp)
 618         {
 619             process_sp->ReadMemory(process_address, bytes, size, error);
 620             if (!error.Success())
 621                 return;
 622         }
 623         break;
 624     }
 625
 626     if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
 627     {
 628         log->Printf("IRMemoryMap::ReadMemory (0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRId64 ") came from [0x%" PRIx64 "..0x%" PRIx64 ")",
 629                     (uint64_t)process_address,
 630                     (uint64_t)bytes,
 631                     (uint64_t)size,
 632                     (uint64_t)allocation.m_process_start,
 633                     (uint64_t)allocation.m_process_start + (uint64_t)allocation.m_size);
 634     }
 635 }
 636
 637 void
 638 IRMemoryMap::ReadScalarFromMemory (Scalar &scalar, lldb::addr_t process_address, size_t size, Error &error)
 639 {
 640     error.Clear();
 641
 642     if (size > 0)
 643     {
 644         DataBufferHeap buf(size, 0);
 645         ReadMemory(buf.GetBytes(), process_address, size, error);
 646
 647         if (!error.Success())
 648             return;
 649
 650         DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(), GetAddressByteSize());
 651
 652         lldb::offset_t offset = 0;
 653
 654         switch (size)
 655         {
 656         default:
 657             error.SetErrorToGenericError();
 658             error.SetErrorStringWithFormat("Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
 659             return;
 660         case 1: scalar = extractor.GetU8(&offset);  break;
 661         case 2: scalar = extractor.GetU16(&offset); break;
 662         case 4: scalar = extractor.GetU32(&offset); break;
 663         case 8: scalar = extractor.GetU64(&offset); break;
 664         }
 665     }
 666     else
 667     {
 668         error.SetErrorToGenericError();
 669         error.SetErrorString ("Couldn't read scalar: its size was zero");
 670     }
 671     return;
 672 }
 673
 674 void
 675 IRMemoryMap::ReadPointerFromMemory (lldb::addr_t *address, lldb::addr_t process_address, Error &error)
 676 {
 677     error.Clear();
 678
 679     Scalar pointer_scalar;
 680     ReadScalarFromMemory(pointer_scalar, process_address, GetAddressByteSize(), error);
 681
 682     if (!error.Success())
 683         return;
 684
 685     *address = pointer_scalar.ULongLong();
 686
 687     return;
 688 }
 689
 690 void
 691 IRMemoryMap::GetMemoryData (DataExtractor &extractor, lldb::addr_t process_address, size_t size, Error &error)
 692 {
 693     error.Clear();
 694
 695     if (size > 0)
 696     {
 697         AllocationMap::iterator iter = FindAllocation(process_address, size);
 698
 699         if (iter == m_allocations.end())
 700         {
 701             error.SetErrorToGenericError();
 702             error.SetErrorStringWithFormat("Couldn't find an allocation containing [0x%" PRIx64 "..0x%" PRIx64 ")", process_address, process_address + size);
 703             return;
 704         }
 705
 706         Allocation &allocation = iter->second;
 707
 708         switch (allocation.m_policy)
 709         {
 710         default:
 711             error.SetErrorToGenericError();
 712             error.SetErrorString("Couldn't get memory data: invalid allocation policy");
 713             return;
 714         case eAllocationPolicyProcessOnly:
 715             error.SetErrorToGenericError();
 716             error.SetErrorString("Couldn't get memory data: memory is only in the target");
 717             return;
 718         case eAllocationPolicyMirror:
 719             {
 720                 lldb::ProcessSP process_sp = m_process_wp.lock();
 721
 722                 if (!allocation.m_data.GetByteSize())
 723                 {
 724                     error.SetErrorToGenericError();
 725                     error.SetErrorString("Couldn't get memory data: data buffer is empty");
 726                     return;
 727                 }
 728                 if (process_sp)
 729                 {
 730                     process_sp->ReadMemory(allocation.m_process_start, allocation.m_data.GetBytes(), allocation.m_data.GetByteSize(), error);
 731                     if (!error.Success())
 732                         return;
 733                     uint64_t offset = process_address - allocation.m_process_start;
 734                     extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size, GetByteOrder(), GetAddressByteSize());
 735                     return;
 736                 }
 737             }
 738         case eAllocationPolicyHostOnly:
 739             if (!allocation.m_data.GetByteSize())
 740             {
 741                 error.SetErrorToGenericError();
 742                 error.SetErrorString("Couldn't get memory data: data buffer is empty");
 743                 return;
 744             }
 745             uint64_t offset = process_address - allocation.m_process_start;
 746             extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size, GetByteOrder(), GetAddressByteSize());
 747             return;
 748         }
 749     }
 750     else
 751     {
 752         error.SetErrorToGenericError();
 753         error.SetErrorString ("Couldn't get memory data: its size was zero");
 754         return;
 755     }
 756 }
 757
 758