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

   1 //===-- Materializer.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/Log.h"
  11 #include "lldb/Core/RegisterValue.h"
  12 #include "lldb/Core/ValueObjectConstResult.h"
  13 #include "lldb/Core/ValueObjectVariable.h"
  14 #include "lldb/Expression/ClangExpressionVariable.h"
  15 #include "lldb/Expression/Materializer.h"
  16 #include "lldb/Symbol/ClangASTContext.h"
  17 #include "lldb/Symbol/Symbol.h"
  18 #include "lldb/Symbol/Type.h"
  19 #include "lldb/Symbol/Variable.h"
  20 #include "lldb/Target/ExecutionContext.h"
  21 #include "lldb/Target/RegisterContext.h"
  22 #include "lldb/Target/StackFrame.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Target/Thread.h"
  25
  26 using namespace lldb_private;
  27
  28 uint32_t
  29 Materializer::AddStructMember (Entity &entity)
  30 {
  31     uint32_t size = entity.GetSize();
  32     uint32_t alignment = entity.GetAlignment();
  33
  34     uint32_t ret;
  35
  36     if (m_current_offset == 0)
  37         m_struct_alignment = alignment;
  38
  39     if (m_current_offset % alignment)
  40         m_current_offset += (alignment - (m_current_offset % alignment));
  41
  42     ret = m_current_offset;
  43
  44     m_current_offset += size;
  45
  46     return ret;
  47 }
  48
  49 void
  50 Materializer::Entity::SetSizeAndAlignmentFromType (ClangASTType &type)
  51 {
  52     m_size = type.GetByteSize();
  53
  54     uint32_t bit_alignment = type.GetTypeBitAlign();
  55
  56     if (bit_alignment % 8)
  57     {
  58         bit_alignment += 8;
  59         bit_alignment &= ~((uint32_t)0x111u);
  60     }
  61
  62     m_alignment = bit_alignment / 8;
  63 }
  64
  65 class EntityPersistentVariable : public Materializer::Entity
  66 {
  67 public:
  68     EntityPersistentVariable (lldb::ClangExpressionVariableSP &persistent_variable_sp) :
  69         Entity(),
  70         m_persistent_variable_sp(persistent_variable_sp)
  71     {
  72         // Hard-coding to maximum size of a pointer since persistent variables are materialized by reference
  73         m_size = 8;
  74         m_alignment = 8;
  75     }
  76
  77     void MakeAllocation (IRMemoryMap &map, Error &err)
  78     {
  79         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
  80
  81         // Allocate a spare memory area to store the persistent variable's contents.
  82
  83         Error allocate_error;
  84
  85         lldb::addr_t mem = map.Malloc(m_persistent_variable_sp->GetByteSize(),
  86                                       8,
  87                                       lldb::ePermissionsReadable | lldb::ePermissionsWritable,
  88                                       IRMemoryMap::eAllocationPolicyMirror,
  89                                       allocate_error);
  90
  91         if (!allocate_error.Success())
  92         {
  93             err.SetErrorStringWithFormat("couldn't allocate a memory area to store %s: %s", m_persistent_variable_sp->GetName().GetCString(), allocate_error.AsCString());
  94             return;
  95         }
  96
  97         if (log)
  98             log->Printf("Allocated %s (0x%" PRIx64 ") sucessfully", m_persistent_variable_sp->GetName().GetCString(), mem);
  99
 100         // Put the location of the spare memory into the live data of the ValueObject.
 101
 102         m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create (map.GetBestExecutionContextScope(),
 103                                                                               m_persistent_variable_sp->GetTypeFromUser(),
 104                                                                               m_persistent_variable_sp->GetName(),
 105                                                                               mem,
 106                                                                               eAddressTypeLoad,
 107                                                                               m_persistent_variable_sp->GetByteSize());
 108
 109         // Clear the flag if the variable will never be deallocated.
 110
 111         if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVKeepInTarget)
 112         {
 113             Error leak_error;
 114             map.Leak(mem, leak_error);
 115             m_persistent_variable_sp->m_flags &= ~ClangExpressionVariable::EVNeedsAllocation;
 116         }
 117
 118         // Write the contents of the variable to the area.
 119
 120         Error write_error;
 121
 122         map.WriteMemory (mem,
 123                          m_persistent_variable_sp->GetValueBytes(),
 124                          m_persistent_variable_sp->GetByteSize(),
 125                          write_error);
 126
 127         if (!write_error.Success())
 128         {
 129             err.SetErrorStringWithFormat ("couldn't write %s to the target: %s", m_persistent_variable_sp->GetName().AsCString(),
 130                                           write_error.AsCString());
 131             return;
 132         }
 133     }
 134
 135     void DestroyAllocation (IRMemoryMap &map, Error &err)
 136     {
 137         Error deallocate_error;
 138
 139         map.Free((lldb::addr_t)m_persistent_variable_sp->m_live_sp->GetValue().GetScalar().ULongLong(), deallocate_error);
 140
 141         m_persistent_variable_sp->m_live_sp.reset();
 142
 143         if (!deallocate_error.Success())
 144         {
 145             err.SetErrorStringWithFormat ("couldn't deallocate memory for %s: %s", m_persistent_variable_sp->GetName().GetCString(), deallocate_error.AsCString());
 146         }
 147     }
 148
 149     void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
 150     {
 151         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 152
 153         const lldb::addr_t load_addr = process_address + m_offset;
 154
 155         if (log)
 156         {
 157             log->Printf("EntityPersistentVariable::Materialize [address = 0x%" PRIx64 ", m_name = %s, m_flags = 0x%hx]",
 158                         (uint64_t)load_addr,
 159                         m_persistent_variable_sp->GetName().AsCString(),
 160                         m_persistent_variable_sp->m_flags);
 161         }
 162
 163         if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVNeedsAllocation)
 164         {
 165             MakeAllocation(map, err);
 166             m_persistent_variable_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
 167
 168             if (!err.Success())
 169                 return;
 170         }
 171
 172         if ((m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVIsProgramReference && m_persistent_variable_sp->m_live_sp) ||
 173             m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVIsLLDBAllocated)
 174         {
 175             Error write_error;
 176
 177             map.WriteScalarToMemory(load_addr,
 178                                     m_persistent_variable_sp->m_live_sp->GetValue().GetScalar(),
 179                                     map.GetAddressByteSize(),
 180                                     write_error);
 181
 182             if (!write_error.Success())
 183             {
 184                 err.SetErrorStringWithFormat("couldn't write the location of %s to memory: %s", m_persistent_variable_sp->GetName().AsCString(), write_error.AsCString());
 185             }
 186         }
 187         else
 188         {
 189             err.SetErrorStringWithFormat("no materialization happened for persistent variable %s", m_persistent_variable_sp->GetName().AsCString());
 190             return;
 191         }
 192     }
 193
 194     void Dematerialize (lldb::StackFrameSP &frame_sp,
 195                         IRMemoryMap &map,
 196                         lldb::addr_t process_address,
 197                         lldb::addr_t frame_top,
 198                         lldb::addr_t frame_bottom,
 199                         Error &err)
 200     {
 201         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 202
 203         const lldb::addr_t load_addr = process_address + m_offset;
 204
 205         if (log)
 206         {
 207             log->Printf("EntityPersistentVariable::Dematerialize [address = 0x%" PRIx64 ", m_name = %s, m_flags = 0x%hx]",
 208                         (uint64_t)process_address + m_offset,
 209                         m_persistent_variable_sp->GetName().AsCString(),
 210                         m_persistent_variable_sp->m_flags);
 211         }
 212
 213         if ((m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVIsLLDBAllocated) ||
 214             (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVIsProgramReference))
 215         {
 216             if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVIsProgramReference &&
 217                 !m_persistent_variable_sp->m_live_sp)
 218             {
 219                 // If the reference comes from the program, then the ClangExpressionVariable's
 220                 // live variable data hasn't been set up yet.  Do this now.
 221
 222                 lldb::addr_t location;
 223                 Error read_error;
 224
 225                 map.ReadPointerFromMemory(&location, load_addr, read_error);
 226
 227                 if (!read_error.Success())
 228                 {
 229                     err.SetErrorStringWithFormat("couldn't read the address of program-allocated variable %s: %s", m_persistent_variable_sp->GetName().GetCString(), read_error.AsCString());
 230                     return;
 231                 }
 232
 233                 m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create (map.GetBestExecutionContextScope (),
 234                                                                                       m_persistent_variable_sp->GetTypeFromUser(),
 235                                                                                       m_persistent_variable_sp->GetName(),
 236                                                                                       location,
 237                                                                                       eAddressTypeLoad,
 238                                                                                       m_persistent_variable_sp->GetByteSize());
 239
 240                 if (frame_top != LLDB_INVALID_ADDRESS &&
 241                     frame_bottom != LLDB_INVALID_ADDRESS &&
 242                     location >= frame_bottom &&
 243                     location <= frame_top)
 244                 {
 245                     // If the variable is resident in the stack frame created by the expression,
 246                     // then it cannot be relied upon to stay around.  We treat it as needing
 247                     // reallocation.
 248                     m_persistent_variable_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
 249                     m_persistent_variable_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
 250                     m_persistent_variable_sp->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
 251                     m_persistent_variable_sp->m_flags &= ~ClangExpressionVariable::EVIsProgramReference;
 252                 }
 253             }
 254
 255             lldb::addr_t mem = m_persistent_variable_sp->m_live_sp->GetValue().GetScalar().ULongLong();
 256
 257             if (!m_persistent_variable_sp->m_live_sp)
 258             {
 259                 err.SetErrorStringWithFormat("couldn't find the memory area used to store %s", m_persistent_variable_sp->GetName().GetCString());
 260                 return;
 261             }
 262
 263             if (m_persistent_variable_sp->m_live_sp->GetValue().GetValueAddressType() != eAddressTypeLoad)
 264             {
 265                 err.SetErrorStringWithFormat("the address of the memory area for %s is in an incorrect format", m_persistent_variable_sp->GetName().GetCString());
 266                 return;
 267             }
 268
 269             if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVNeedsFreezeDry ||
 270                 m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVKeepInTarget)
 271             {
 272                 if (log)
 273                     log->Printf("Dematerializing %s from 0x%" PRIx64 " (size = %llu)", m_persistent_variable_sp->GetName().GetCString(), (uint64_t)mem, (unsigned long long)m_persistent_variable_sp->GetByteSize());
 274
 275                 // Read the contents of the spare memory area
 276
 277                 m_persistent_variable_sp->ValueUpdated ();
 278
 279                 Error read_error;
 280
 281                 map.ReadMemory(m_persistent_variable_sp->GetValueBytes(),
 282                                mem,
 283                                m_persistent_variable_sp->GetByteSize(),
 284                                read_error);
 285
 286                 if (!read_error.Success())
 287                 {
 288                     err.SetErrorStringWithFormat ("couldn't read the contents of %s from memory: %s", m_persistent_variable_sp->GetName().GetCString(), read_error.AsCString());
 289                     return;
 290                 }
 291
 292                 m_persistent_variable_sp->m_flags &= ~ClangExpressionVariable::EVNeedsFreezeDry;
 293             }
 294         }
 295         else
 296         {
 297             err.SetErrorStringWithFormat("no dematerialization happened for persistent variable %s", m_persistent_variable_sp->GetName().AsCString());
 298             return;
 299         }
 300
 301         lldb::ProcessSP process_sp = map.GetBestExecutionContextScope()->CalculateProcess();
 302         if (!process_sp ||
 303             !process_sp->CanJIT())
 304         {
 305             // Allocations are not persistent so persistent variables cannot stay materialized.
 306
 307             m_persistent_variable_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
 308
 309             DestroyAllocation(map, err);
 310             if (!err.Success())
 311                 return;
 312         }
 313         else if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVNeedsAllocation &&
 314                  !(m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVKeepInTarget))
 315         {
 316             DestroyAllocation(map, err);
 317             if (!err.Success())
 318                 return;
 319         }
 320     }
 321
 322     void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
 323     {
 324         StreamString dump_stream;
 325
 326         Error err;
 327
 328         const lldb::addr_t load_addr = process_address + m_offset;
 329
 330         dump_stream.Printf("0x%" PRIx64 ": EntityPersistentVariable (%s)\n", load_addr, m_persistent_variable_sp->GetName().AsCString());
 331
 332         {
 333             dump_stream.Printf("Pointer:\n");
 334
 335             DataBufferHeap data (m_size, 0);
 336
 337             map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
 338
 339             if (!err.Success())
 340             {
 341                 dump_stream.Printf("  <could not be read>\n");
 342             }
 343             else
 344             {
 345                 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
 346
 347                 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
 348
 349                 dump_stream.PutChar('\n');
 350             }
 351         }
 352
 353         {
 354             dump_stream.Printf("Target:\n");
 355
 356             lldb::addr_t target_address;
 357
 358             map.ReadPointerFromMemory (&target_address, load_addr, err);
 359
 360             if (!err.Success())
 361             {
 362                 dump_stream.Printf("  <could not be read>\n");
 363             }
 364             else
 365             {
 366                 DataBufferHeap data (m_persistent_variable_sp->GetByteSize(), 0);
 367
 368                 map.ReadMemory(data.GetBytes(), target_address, m_persistent_variable_sp->GetByteSize(), err);
 369
 370                 if (!err.Success())
 371                 {
 372                     dump_stream.Printf("  <could not be read>\n");
 373                 }
 374                 else
 375                 {
 376                     DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
 377
 378                     extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, target_address);
 379
 380                     dump_stream.PutChar('\n');
 381                 }
 382             }
 383         }
 384
 385         log->PutCString(dump_stream.GetData());
 386     }
 387
 388     void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
 389     {
 390     }
 391 private:
 392     lldb::ClangExpressionVariableSP m_persistent_variable_sp;
 393 };
 394
 395 uint32_t
 396 Materializer::AddPersistentVariable (lldb::ClangExpressionVariableSP &persistent_variable_sp, Error &err)
 397 {
 398     EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
 399     iter->reset (new EntityPersistentVariable (persistent_variable_sp));
 400     uint32_t ret = AddStructMember(**iter);
 401     (*iter)->SetOffset(ret);
 402     return ret;
 403 }
 404
 405 class EntityVariable : public Materializer::Entity
 406 {
 407 public:
 408     EntityVariable (lldb::VariableSP &variable_sp) :
 409         Entity(),
 410         m_variable_sp(variable_sp),
 411         m_is_reference(false),
 412         m_temporary_allocation(LLDB_INVALID_ADDRESS),
 413         m_temporary_allocation_size(0)
 414     {
 415         // Hard-coding to maximum size of a pointer since all variables are materialized by reference
 416         m_size = 8;
 417         m_alignment = 8;
 418         m_is_reference = m_variable_sp->GetType()->GetClangForwardType().IsReferenceType();
 419     }
 420
 421     void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
 422     {
 423         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 424
 425         const lldb::addr_t load_addr = process_address + m_offset;
 426         if (log)
 427         {
 428             log->Printf("EntityVariable::Materialize [address = 0x%" PRIx64 ", m_variable_sp = %s]",
 429                         (uint64_t)load_addr,
 430                         m_variable_sp->GetName().AsCString());
 431         }
 432
 433         ExecutionContextScope *scope = frame_sp.get();
 434
 435         if (!scope)
 436             scope = map.GetBestExecutionContextScope();
 437
 438         lldb::ValueObjectSP valobj_sp = ValueObjectVariable::Create(scope, m_variable_sp);
 439
 440         if (!valobj_sp)
 441         {
 442             err.SetErrorStringWithFormat("couldn't get a value object for variable %s", m_variable_sp->GetName().AsCString());
 443             return;
 444         }
 445
 446         if (m_is_reference)
 447         {
 448             DataExtractor valobj_extractor;
 449             valobj_sp->GetData(valobj_extractor);
 450             lldb::offset_t offset = 0;
 451             lldb::addr_t reference_addr = valobj_extractor.GetAddress(&offset);
 452
 453             Error write_error;
 454             map.WritePointerToMemory(load_addr, reference_addr, write_error);
 455
 456             if (!write_error.Success())
 457             {
 458                 err.SetErrorStringWithFormat("couldn't write the contents of reference variable %s to memory: %s", m_variable_sp->GetName().AsCString(), write_error.AsCString());
 459                 return;
 460             }
 461         }
 462         else
 463         {
 464             lldb::addr_t addr_of_valobj = valobj_sp->GetAddressOf();
 465             if (addr_of_valobj != LLDB_INVALID_ADDRESS)
 466             {
 467                 Error write_error;
 468                 map.WritePointerToMemory(load_addr, addr_of_valobj, write_error);
 469
 470                 if (!write_error.Success())
 471                 {
 472                     err.SetErrorStringWithFormat("couldn't write the address of variable %s to memory: %s", m_variable_sp->GetName().AsCString(), write_error.AsCString());
 473                     return;
 474                 }
 475             }
 476             else
 477             {
 478                 DataExtractor data;
 479                 valobj_sp->GetData(data);
 480
 481                 if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
 482                 {
 483                     err.SetErrorStringWithFormat("trying to create a temporary region for %s but one exists", m_variable_sp->GetName().AsCString());
 484                     return;
 485                 }
 486
 487                 if (data.GetByteSize() != m_variable_sp->GetType()->GetByteSize())
 488                 {
 489                     if (data.GetByteSize() == 0 && m_variable_sp->LocationExpression().IsValid() == false)
 490                     {
 491                         err.SetErrorStringWithFormat("the variable '%s' has no location, it may have been optimized out", m_variable_sp->GetName().AsCString());
 492                     }
 493                     else
 494                     {
 495                         err.SetErrorStringWithFormat("size of variable %s (%" PRIu64 ") disagrees with the ValueObject's size (%" PRIu64 ")",
 496                                                      m_variable_sp->GetName().AsCString(),
 497                                                      m_variable_sp->GetType()->GetByteSize(),
 498                                                      data.GetByteSize());
 499                     }
 500                     return;
 501                 }
 502
 503                 size_t bit_align = m_variable_sp->GetType()->GetClangLayoutType().GetTypeBitAlign();
 504                 size_t byte_align = (bit_align + 7) / 8;
 505
 506                 Error alloc_error;
 507
 508                 m_temporary_allocation = map.Malloc(data.GetByteSize(), byte_align, lldb::ePermissionsReadable | lldb::ePermissionsWritable, IRMemoryMap::eAllocationPolicyMirror, alloc_error);
 509                 m_temporary_allocation_size = data.GetByteSize();
 510
 511                 if (!alloc_error.Success())
 512                 {
 513                     err.SetErrorStringWithFormat("couldn't allocate a temporary region for %s: %s", m_variable_sp->GetName().AsCString(), alloc_error.AsCString());
 514                     return;
 515                 }
 516
 517                 Error write_error;
 518
 519                 map.WriteMemory(m_temporary_allocation, data.GetDataStart(), data.GetByteSize(), write_error);
 520
 521                 if (!write_error.Success())
 522                 {
 523                     err.SetErrorStringWithFormat("couldn't write to the temporary region for %s: %s", m_variable_sp->GetName().AsCString(), write_error.AsCString());
 524                     return;
 525                 }
 526
 527                 Error pointer_write_error;
 528
 529                 map.WritePointerToMemory(load_addr, m_temporary_allocation, pointer_write_error);
 530
 531                 if (!pointer_write_error.Success())
 532                 {
 533                     err.SetErrorStringWithFormat("couldn't write the address of the temporary region for %s: %s", m_variable_sp->GetName().AsCString(), pointer_write_error.AsCString());
 534                 }
 535             }
 536         }
 537     }
 538
 539     void Dematerialize (lldb::StackFrameSP &frame_sp,
 540                         IRMemoryMap &map,
 541                         lldb::addr_t process_address,
 542                         lldb::addr_t frame_top,
 543                         lldb::addr_t frame_bottom,
 544                         Error &err)
 545     {
 546         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 547
 548         const lldb::addr_t load_addr = process_address + m_offset;
 549         if (log)
 550         {
 551             log->Printf("EntityVariable::Dematerialize [address = 0x%" PRIx64 ", m_variable_sp = %s]",
 552                         (uint64_t)load_addr,
 553                         m_variable_sp->GetName().AsCString());
 554         }
 555
 556         if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
 557         {
 558             ExecutionContextScope *scope = frame_sp.get();
 559
 560             if (!scope)
 561                 scope = map.GetBestExecutionContextScope();
 562
 563             lldb::ValueObjectSP valobj_sp = ValueObjectVariable::Create(scope, m_variable_sp);
 564
 565             if (!valobj_sp)
 566             {
 567                 err.SetErrorStringWithFormat("couldn't get a value object for variable %s", m_variable_sp->GetName().AsCString());
 568                 return;
 569             }
 570
 571             lldb_private::DataExtractor data;
 572
 573             Error extract_error;
 574
 575             map.GetMemoryData(data, m_temporary_allocation, valobj_sp->GetByteSize(), extract_error);
 576
 577             if (!extract_error.Success())
 578             {
 579                 err.SetErrorStringWithFormat("couldn't get the data for variable %s", m_variable_sp->GetName().AsCString());
 580                 return;
 581             }
 582
 583             Error set_error;
 584
 585             valobj_sp->SetData(data, set_error);
 586
 587             if (!set_error.Success())
 588             {
 589                 err.SetErrorStringWithFormat("couldn't write the new contents of %s back into the variable", m_variable_sp->GetName().AsCString());
 590                 return;
 591             }
 592
 593             Error free_error;
 594
 595             map.Free(m_temporary_allocation, free_error);
 596
 597             if (!free_error.Success())
 598             {
 599                 err.SetErrorStringWithFormat("couldn't free the temporary region for %s: %s", m_variable_sp->GetName().AsCString(), free_error.AsCString());
 600                 return;
 601             }
 602
 603             m_temporary_allocation = LLDB_INVALID_ADDRESS;
 604             m_temporary_allocation_size = 0;
 605         }
 606     }
 607
 608     void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
 609     {
 610         StreamString dump_stream;
 611
 612         const lldb::addr_t load_addr = process_address + m_offset;
 613         dump_stream.Printf("0x%" PRIx64 ": EntityVariable\n", load_addr);
 614
 615         Error err;
 616
 617         lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
 618
 619         {
 620             dump_stream.Printf("Pointer:\n");
 621
 622             DataBufferHeap data (m_size, 0);
 623
 624             map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
 625
 626             if (!err.Success())
 627             {
 628                 dump_stream.Printf("  <could not be read>\n");
 629             }
 630             else
 631             {
 632                 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
 633
 634                 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
 635
 636                 lldb::offset_t offset;
 637
 638                 ptr = extractor.GetPointer(&offset);
 639
 640                 dump_stream.PutChar('\n');
 641             }
 642         }
 643
 644         if (m_temporary_allocation == LLDB_INVALID_ADDRESS)
 645         {
 646             dump_stream.Printf("Points to process memory:\n");
 647         }
 648         else
 649         {
 650             dump_stream.Printf("Temporary allocation:\n");
 651         }
 652
 653         if (ptr == LLDB_INVALID_ADDRESS)
 654         {
 655             dump_stream.Printf("  <could not be be found>\n");
 656         }
 657         else
 658         {
 659             DataBufferHeap data (m_temporary_allocation_size, 0);
 660
 661             map.ReadMemory(data.GetBytes(), m_temporary_allocation, m_temporary_allocation_size, err);
 662
 663             if (!err.Success())
 664             {
 665                 dump_stream.Printf("  <could not be read>\n");
 666             }
 667             else
 668             {
 669                 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
 670
 671                 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
 672
 673                 dump_stream.PutChar('\n');
 674             }
 675         }
 676
 677         log->PutCString(dump_stream.GetData());
 678     }
 679
 680     void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
 681     {
 682         if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
 683         {
 684             Error free_error;
 685
 686             map.Free(m_temporary_allocation, free_error);
 687
 688             m_temporary_allocation = LLDB_INVALID_ADDRESS;
 689             m_temporary_allocation_size = 0;
 690         }
 691
 692     }
 693 private:
 694     lldb::VariableSP    m_variable_sp;
 695     bool                m_is_reference;
 696     lldb::addr_t        m_temporary_allocation;
 697     size_t              m_temporary_allocation_size;
 698 };
 699
 700 uint32_t
 701 Materializer::AddVariable (lldb::VariableSP &variable_sp, Error &err)
 702 {
 703     EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
 704     iter->reset (new EntityVariable (variable_sp));
 705     uint32_t ret = AddStructMember(**iter);
 706     (*iter)->SetOffset(ret);
 707     return ret;
 708 }
 709
 710 class EntityResultVariable : public Materializer::Entity
 711 {
 712 public:
 713     EntityResultVariable (const TypeFromUser &type, bool is_program_reference, bool keep_in_memory) :
 714         Entity(),
 715         m_type(type),
 716         m_is_program_reference(is_program_reference),
 717         m_keep_in_memory(keep_in_memory),
 718         m_temporary_allocation(LLDB_INVALID_ADDRESS),
 719         m_temporary_allocation_size(0)
 720     {
 721         // Hard-coding to maximum size of a pointer since all results are materialized by reference
 722         m_size = 8;
 723         m_alignment = 8;
 724     }
 725
 726     void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
 727     {
 728         if (!m_is_program_reference)
 729         {
 730             if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
 731             {
 732                 err.SetErrorString("Trying to create a temporary region for the result but one exists");
 733                 return;
 734             }
 735
 736             const lldb::addr_t load_addr = process_address + m_offset;
 737
 738             size_t byte_size = m_type.GetByteSize();
 739             size_t bit_align = m_type.GetTypeBitAlign();
 740             size_t byte_align = (bit_align + 7) / 8;
 741
 742             Error alloc_error;
 743
 744             m_temporary_allocation = map.Malloc(byte_size, byte_align, lldb::ePermissionsReadable | lldb::ePermissionsWritable, IRMemoryMap::eAllocationPolicyMirror, alloc_error);
 745             m_temporary_allocation_size = byte_size;
 746
 747             if (!alloc_error.Success())
 748             {
 749                 err.SetErrorStringWithFormat("couldn't allocate a temporary region for the result: %s", alloc_error.AsCString());
 750                 return;
 751             }
 752
 753             Error pointer_write_error;
 754
 755             map.WritePointerToMemory(load_addr, m_temporary_allocation, pointer_write_error);
 756
 757             if (!pointer_write_error.Success())
 758             {
 759                 err.SetErrorStringWithFormat("couldn't write the address of the temporary region for the result: %s", pointer_write_error.AsCString());
 760             }
 761         }
 762     }
 763
 764     void Dematerialize (lldb::StackFrameSP &frame_sp,
 765                         IRMemoryMap &map,
 766                         lldb::addr_t process_address,
 767                         lldb::addr_t frame_top,
 768                         lldb::addr_t frame_bottom,
 769                         Error &err)
 770     {
 771         err.SetErrorString("Tried to detmaterialize a result variable with the normal Dematerialize method");
 772     }
 773
 774     void Dematerialize (lldb::ClangExpressionVariableSP &result_variable_sp,
 775                         lldb::StackFrameSP &frame_sp,
 776                         IRMemoryMap &map,
 777                         lldb::addr_t process_address,
 778                         lldb::addr_t frame_top,
 779                         lldb::addr_t frame_bottom,
 780                         Error &err)
 781     {
 782         err.Clear();
 783
 784         ExecutionContextScope *exe_scope = map.GetBestExecutionContextScope();
 785
 786         if (!exe_scope)
 787         {
 788             err.SetErrorString("Couldn't dematerialize a result variable: invalid execution context scope");
 789             return;
 790         }
 791
 792         lldb::addr_t address;
 793         Error read_error;
 794         const lldb::addr_t load_addr = process_address + m_offset;
 795
 796         map.ReadPointerFromMemory (&address, load_addr, read_error);
 797
 798         if (!read_error.Success())
 799         {
 800             err.SetErrorString("Couldn't dematerialize a result variable: couldn't read its address");
 801             return;
 802         }
 803
 804         lldb::TargetSP target_sp = exe_scope->CalculateTarget();
 805
 806         if (!target_sp)
 807         {
 808             err.SetErrorString("Couldn't dematerialize a result variable: no target");
 809             return;
 810         }
 811
 812         ConstString name = target_sp->GetPersistentVariables().GetNextPersistentVariableName();
 813
 814         lldb::ClangExpressionVariableSP ret;
 815
 816         ret = target_sp->GetPersistentVariables().CreateVariable(exe_scope,
 817                                                                  name,
 818                                                                  m_type,
 819                                                                  map.GetByteOrder(),
 820                                                                  map.GetAddressByteSize());
 821
 822         if (!ret)
 823         {
 824             err.SetErrorStringWithFormat("couldn't dematerialize a result variable: failed to make persistent variable %s", name.AsCString());
 825             return;
 826         }
 827
 828         lldb::ProcessSP process_sp = map.GetBestExecutionContextScope()->CalculateProcess();
 829
 830         bool can_persist = (m_is_program_reference && process_sp && process_sp->CanJIT() && !(address >= frame_bottom && address < frame_top));
 831
 832         if (can_persist && m_keep_in_memory)
 833         {
 834             ret->m_live_sp = ValueObjectConstResult::Create(exe_scope,
 835                                                             m_type,
 836                                                             name,
 837                                                             address,
 838                                                             eAddressTypeLoad,
 839                                                             map.GetAddressByteSize());
 840         }
 841
 842         ret->ValueUpdated();
 843
 844         const size_t pvar_byte_size = ret->GetByteSize();
 845         uint8_t *pvar_data = ret->GetValueBytes();
 846
 847         map.ReadMemory(pvar_data, address, pvar_byte_size, read_error);
 848
 849         if (!read_error.Success())
 850         {
 851             err.SetErrorString("Couldn't dematerialize a result variable: couldn't read its memory");
 852             return;
 853         }
 854
 855         result_variable_sp = ret;
 856
 857         if (!can_persist || !m_keep_in_memory)
 858         {
 859             ret->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
 860
 861             if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
 862             {
 863                 Error free_error;
 864                 map.Free(m_temporary_allocation, free_error);
 865             }
 866         }
 867         else
 868         {
 869             ret->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
 870         }
 871
 872         m_temporary_allocation = LLDB_INVALID_ADDRESS;
 873         m_temporary_allocation_size = 0;
 874     }
 875
 876     void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
 877     {
 878         StreamString dump_stream;
 879
 880         const lldb::addr_t load_addr = process_address + m_offset;
 881
 882         dump_stream.Printf("0x%" PRIx64 ": EntityResultVariable\n", load_addr);
 883
 884         Error err;
 885
 886         lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
 887
 888         {
 889             dump_stream.Printf("Pointer:\n");
 890
 891             DataBufferHeap data (m_size, 0);
 892
 893             map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
 894
 895             if (!err.Success())
 896             {
 897                 dump_stream.Printf("  <could not be read>\n");
 898             }
 899             else
 900             {
 901                 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
 902
 903                 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
 904
 905                 lldb::offset_t offset;
 906
 907                 ptr = extractor.GetPointer(&offset);
 908
 909                 dump_stream.PutChar('\n');
 910             }
 911         }
 912
 913         if (m_temporary_allocation == LLDB_INVALID_ADDRESS)
 914         {
 915             dump_stream.Printf("Points to process memory:\n");
 916         }
 917         else
 918         {
 919             dump_stream.Printf("Temporary allocation:\n");
 920         }
 921
 922         if (ptr == LLDB_INVALID_ADDRESS)
 923         {
 924             dump_stream.Printf("  <could not be be found>\n");
 925         }
 926         else
 927         {
 928             DataBufferHeap data (m_temporary_allocation_size, 0);
 929
 930             map.ReadMemory(data.GetBytes(), m_temporary_allocation, m_temporary_allocation_size, err);
 931
 932             if (!err.Success())
 933             {
 934                 dump_stream.Printf("  <could not be read>\n");
 935             }
 936             else
 937             {
 938                 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
 939
 940                 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
 941
 942                 dump_stream.PutChar('\n');
 943             }
 944         }
 945
 946         log->PutCString(dump_stream.GetData());
 947     }
 948
 949     void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
 950     {
 951         if (!m_keep_in_memory && m_temporary_allocation != LLDB_INVALID_ADDRESS)
 952         {
 953             Error free_error;
 954
 955             map.Free(m_temporary_allocation, free_error);
 956         }
 957
 958         m_temporary_allocation = LLDB_INVALID_ADDRESS;
 959         m_temporary_allocation_size = 0;
 960     }
 961 private:
 962     TypeFromUser    m_type;
 963     bool            m_is_program_reference;
 964     bool            m_keep_in_memory;
 965
 966     lldb::addr_t    m_temporary_allocation;
 967     size_t          m_temporary_allocation_size;
 968 };
 969
 970 uint32_t
 971 Materializer::AddResultVariable (const TypeFromUser &type, bool is_program_reference, bool keep_in_memory, Error &err)
 972 {
 973     EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
 974     iter->reset (new EntityResultVariable (type, is_program_reference, keep_in_memory));
 975     uint32_t ret = AddStructMember(**iter);
 976     (*iter)->SetOffset(ret);
 977     m_result_entity = iter->get();
 978     return ret;
 979 }
 980
 981 class EntitySymbol : public Materializer::Entity
 982 {
 983 public:
 984     EntitySymbol (const Symbol &symbol) :
 985         Entity(),
 986         m_symbol(symbol)
 987     {
 988         // Hard-coding to maximum size of a symbol
 989         m_size = 8;
 990         m_alignment = 8;
 991     }
 992
 993     void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
 994     {
 995         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 996
 997         const lldb::addr_t load_addr = process_address + m_offset;
 998
 999         if (log)
1000         {
1001             log->Printf("EntitySymbol::Materialize [address = 0x%" PRIx64 ", m_symbol = %s]",
1002                         (uint64_t)load_addr,
1003                         m_symbol.GetName().AsCString());
1004         }
1005
1006         Address &sym_address = m_symbol.GetAddress();
1007
1008         ExecutionContextScope *exe_scope = map.GetBestExecutionContextScope();
1009
1010         lldb::TargetSP target_sp;
1011
1012         if (exe_scope)
1013             target_sp = map.GetBestExecutionContextScope()->CalculateTarget();
1014
1015         if (!target_sp)
1016         {
1017             err.SetErrorStringWithFormat("couldn't resolve symbol %s because there is no target", m_symbol.GetName().AsCString());
1018             return;
1019         }
1020
1021         lldb::addr_t resolved_address = sym_address.GetLoadAddress(target_sp.get());
1022
1023         if (resolved_address == LLDB_INVALID_ADDRESS)
1024             resolved_address = sym_address.GetFileAddress();
1025
1026         Error pointer_write_error;
1027
1028         map.WritePointerToMemory(load_addr, resolved_address, pointer_write_error);
1029
1030         if (!pointer_write_error.Success())
1031         {
1032             err.SetErrorStringWithFormat("couldn't write the address of symbol %s: %s", m_symbol.GetName().AsCString(), pointer_write_error.AsCString());
1033             return;
1034         }
1035     }
1036
1037     void Dematerialize (lldb::StackFrameSP &frame_sp,
1038                         IRMemoryMap &map,
1039                         lldb::addr_t process_address,
1040                         lldb::addr_t frame_top,
1041                         lldb::addr_t frame_bottom,
1042                         Error &err)
1043     {
1044         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1045
1046         const lldb::addr_t load_addr = process_address + m_offset;
1047
1048         if (log)
1049         {
1050             log->Printf("EntitySymbol::Dematerialize [address = 0x%" PRIx64 ", m_symbol = %s]",
1051                         (uint64_t)load_addr,
1052                         m_symbol.GetName().AsCString());
1053         }
1054
1055         // no work needs to be done
1056     }
1057
1058     void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
1059     {
1060         StreamString dump_stream;
1061
1062         Error err;
1063
1064         const lldb::addr_t load_addr = process_address + m_offset;
1065
1066         dump_stream.Printf("0x%" PRIx64 ": EntitySymbol (%s)\n", load_addr, m_symbol.GetName().AsCString());
1067
1068         {
1069             dump_stream.Printf("Pointer:\n");
1070
1071             DataBufferHeap data (m_size, 0);
1072
1073             map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
1074
1075             if (!err.Success())
1076             {
1077                 dump_stream.Printf("  <could not be read>\n");
1078             }
1079             else
1080             {
1081                 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
1082
1083                 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
1084
1085                 dump_stream.PutChar('\n');
1086             }
1087         }
1088
1089         log->PutCString(dump_stream.GetData());
1090     }
1091
1092     void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
1093     {
1094     }
1095 private:
1096     Symbol m_symbol;
1097 };
1098
1099 uint32_t
1100 Materializer::AddSymbol (const Symbol &symbol_sp, Error &err)
1101 {
1102     EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
1103     iter->reset (new EntitySymbol (symbol_sp));
1104     uint32_t ret = AddStructMember(**iter);
1105     (*iter)->SetOffset(ret);
1106     return ret;
1107 }
1108
1109 class EntityRegister : public Materializer::Entity
1110 {
1111 public:
1112     EntityRegister (const RegisterInfo &register_info) :
1113         Entity(),
1114         m_register_info(register_info)
1115     {
1116         // Hard-coding alignment conservatively
1117         m_size = m_register_info.byte_size;
1118         m_alignment = m_register_info.byte_size;
1119     }
1120
1121     void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
1122     {
1123         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1124
1125         const lldb::addr_t load_addr = process_address + m_offset;
1126
1127         if (log)
1128         {
1129             log->Printf("EntityRegister::Materialize [address = 0x%" PRIx64 ", m_register_info = %s]",
1130                         (uint64_t)load_addr,
1131                         m_register_info.name);
1132         }
1133
1134         RegisterValue reg_value;
1135
1136         if (!frame_sp.get())
1137         {
1138             err.SetErrorStringWithFormat("couldn't materialize register %s without a stack frame", m_register_info.name);
1139             return;
1140         }
1141
1142         lldb::RegisterContextSP reg_context_sp = frame_sp->GetRegisterContext();
1143
1144         if (!reg_context_sp->ReadRegister(&m_register_info, reg_value))
1145         {
1146             err.SetErrorStringWithFormat("couldn't read the value of register %s", m_register_info.name);
1147             return;
1148         }
1149
1150         DataExtractor register_data;
1151
1152         if (!reg_value.GetData(register_data))
1153         {
1154             err.SetErrorStringWithFormat("couldn't get the data for register %s", m_register_info.name);
1155             return;
1156         }
1157
1158         if (register_data.GetByteSize() != m_register_info.byte_size)
1159         {
1160             err.SetErrorStringWithFormat("data for register %s had size %llu but we expected %llu", m_register_info.name, (unsigned long long)register_data.GetByteSize(), (unsigned long long)m_register_info.byte_size);
1161             return;
1162         }
1163
1164         m_register_contents.reset(new DataBufferHeap(register_data.GetDataStart(), register_data.GetByteSize()));
1165
1166         Error write_error;
1167
1168         map.WriteMemory(load_addr, register_data.GetDataStart(), register_data.GetByteSize(), write_error);
1169
1170         if (!write_error.Success())
1171         {
1172             err.SetErrorStringWithFormat("couldn't write the contents of register %s: %s", m_register_info.name, write_error.AsCString());
1173             return;
1174         }
1175     }
1176
1177     void Dematerialize (lldb::StackFrameSP &frame_sp,
1178                         IRMemoryMap &map,
1179                         lldb::addr_t process_address,
1180                         lldb::addr_t frame_top,
1181                         lldb::addr_t frame_bottom,
1182                         Error &err)
1183     {
1184         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1185
1186         const lldb::addr_t load_addr = process_address + m_offset;
1187
1188         if (log)
1189         {
1190             log->Printf("EntityRegister::Dematerialize [address = 0x%" PRIx64 ", m_register_info = %s]",
1191                         (uint64_t)load_addr,
1192                         m_register_info.name);
1193         }
1194
1195         Error extract_error;
1196
1197         DataExtractor register_data;
1198
1199         if (!frame_sp.get())
1200         {
1201             err.SetErrorStringWithFormat("couldn't dematerialize register %s without a stack frame", m_register_info.name);
1202             return;
1203         }
1204
1205         lldb::RegisterContextSP reg_context_sp = frame_sp->GetRegisterContext();
1206
1207         map.GetMemoryData(register_data, load_addr, m_register_info.byte_size, extract_error);
1208
1209         if (!extract_error.Success())
1210         {
1211             err.SetErrorStringWithFormat("couldn't get the data for register %s: %s", m_register_info.name, extract_error.AsCString());
1212             return;
1213         }
1214
1215         if (!memcmp(register_data.GetDataStart(), m_register_contents->GetBytes(), register_data.GetByteSize()))
1216         {
1217             // No write required, and in particular we avoid errors if the register wasn't writable
1218
1219             m_register_contents.reset();
1220             return;
1221         }
1222
1223         m_register_contents.reset();
1224
1225         RegisterValue register_value (const_cast<uint8_t*>(register_data.GetDataStart()), register_data.GetByteSize(), register_data.GetByteOrder());
1226
1227         if (!reg_context_sp->WriteRegister(&m_register_info, register_value))
1228         {
1229             err.SetErrorStringWithFormat("couldn't write the value of register %s", m_register_info.name);
1230             return;
1231         }
1232     }
1233
1234     void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
1235     {
1236         StreamString dump_stream;
1237
1238         Error err;
1239
1240         const lldb::addr_t load_addr = process_address + m_offset;
1241
1242
1243         dump_stream.Printf("0x%" PRIx64 ": EntityRegister (%s)\n", load_addr, m_register_info.name);
1244
1245         {
1246             dump_stream.Printf("Value:\n");
1247
1248             DataBufferHeap data (m_size, 0);
1249
1250             map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
1251
1252             if (!err.Success())
1253             {
1254                 dump_stream.Printf("  <could not be read>\n");
1255             }
1256             else
1257             {
1258                 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
1259
1260                 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
1261
1262                 dump_stream.PutChar('\n');
1263             }
1264         }
1265
1266         log->PutCString(dump_stream.GetData());
1267     }
1268
1269     void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
1270     {
1271     }
1272 private:
1273     RegisterInfo m_register_info;
1274     lldb::DataBufferSP m_register_contents;
1275 };
1276
1277 uint32_t
1278 Materializer::AddRegister (const RegisterInfo &register_info, Error &err)
1279 {
1280     EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
1281     iter->reset (new EntityRegister (register_info));
1282     uint32_t ret = AddStructMember(**iter);
1283     (*iter)->SetOffset(ret);
1284     return ret;
1285 }
1286
1287 Materializer::Materializer () :
1288     m_dematerializer_wp(),
1289     m_result_entity(NULL),
1290     m_current_offset(0),
1291     m_struct_alignment(8)
1292 {
1293 }
1294
1295 Materializer::~Materializer ()
1296 {
1297     DematerializerSP dematerializer_sp = m_dematerializer_wp.lock();
1298
1299     if (dematerializer_sp)
1300         dematerializer_sp->Wipe();
1301 }
1302
1303 Materializer::DematerializerSP
1304 Materializer::Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &error)
1305 {
1306     ExecutionContextScope *exe_scope = frame_sp.get();
1307
1308     if (!exe_scope)
1309         exe_scope = map.GetBestExecutionContextScope();
1310
1311     DematerializerSP dematerializer_sp = m_dematerializer_wp.lock();
1312
1313     if (dematerializer_sp)
1314     {
1315         error.SetErrorToGenericError();
1316         error.SetErrorString("Couldn't materialize: already materialized");
1317     }
1318
1319     DematerializerSP ret(new Dematerializer(*this, frame_sp, map, process_address));
1320
1321     if (!exe_scope)
1322     {
1323         error.SetErrorToGenericError();
1324         error.SetErrorString("Couldn't materialize: target doesn't exist");
1325     }
1326
1327     for (EntityUP &entity_up : m_entities)
1328     {
1329         entity_up->Materialize(frame_sp, map, process_address, error);
1330
1331         if (!error.Success())
1332             return DematerializerSP();
1333     }
1334
1335     if (Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
1336     {
1337         log->Printf("Materializer::Materialize (frame_sp = %p, process_address = 0x%" PRIx64 ") materialized:", frame_sp.get(), process_address);
1338         for (EntityUP &entity_up : m_entities)
1339             entity_up->DumpToLog(map, process_address, log);
1340     }
1341
1342     m_dematerializer_wp = ret;
1343
1344     return ret;
1345 }
1346
1347 void
1348 Materializer::Dematerializer::Dematerialize (Error &error, lldb::ClangExpressionVariableSP &result_sp, lldb::addr_t frame_bottom, lldb::addr_t frame_top)
1349 {
1350     lldb::StackFrameSP frame_sp;
1351
1352     lldb::ThreadSP thread_sp = m_thread_wp.lock();
1353     if (thread_sp)
1354         frame_sp = thread_sp->GetFrameWithStackID(m_stack_id);
1355
1356     ExecutionContextScope *exe_scope = m_map->GetBestExecutionContextScope();
1357
1358     if (!IsValid())
1359     {
1360         error.SetErrorToGenericError();
1361         error.SetErrorString("Couldn't dematerialize: invalid dematerializer");
1362     }
1363
1364     if (!exe_scope)
1365     {
1366         error.SetErrorToGenericError();
1367         error.SetErrorString("Couldn't dematerialize: target is gone");
1368     }
1369     else
1370     {
1371         if (Log *log =lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
1372         {
1373             log->Printf("Materializer::Dematerialize (frame_sp = %p, process_address = 0x%" PRIx64 ") about to dematerialize:", frame_sp.get(), m_process_address);
1374             for (EntityUP &entity_up : m_materializer->m_entities)
1375                 entity_up->DumpToLog(*m_map, m_process_address, log);
1376         }
1377
1378         for (EntityUP &entity_up : m_materializer->m_entities)
1379         {
1380             if (entity_up.get() == m_materializer->m_result_entity)
1381             {
1382                 static_cast<EntityResultVariable*>(m_materializer->m_result_entity)->Dematerialize (result_sp, frame_sp, *m_map, m_process_address, frame_top, frame_bottom, error);
1383             }
1384             else
1385             {
1386                 entity_up->Dematerialize (frame_sp, *m_map, m_process_address, frame_top, frame_bottom, error);
1387             }
1388
1389             if (!error.Success())
1390                 break;
1391         }
1392     }
1393
1394     Wipe();
1395 }
1396
1397 void
1398 Materializer::Dematerializer::Wipe ()
1399 {
1400     if (!IsValid())
1401         return;
1402
1403     for (EntityUP &entity_up : m_materializer->m_entities)
1404     {
1405         entity_up->Wipe (*m_map, m_process_address);
1406     }
1407
1408     m_materializer = NULL;
1409     m_map = NULL;
1410     m_process_address = LLDB_INVALID_ADDRESS;
1411 }