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