1 //===-- Materializer.cpp ----------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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"
26 using namespace lldb_private;
29 Materializer::AddStructMember (Entity &entity)
31 uint32_t size = entity.GetSize();
32 uint32_t alignment = entity.GetAlignment();
36 if (m_current_offset == 0)
37 m_struct_alignment = alignment;
39 if (m_current_offset % alignment)
40 m_current_offset += (alignment - (m_current_offset % alignment));
42 ret = m_current_offset;
44 m_current_offset += size;
50 Materializer::Entity::SetSizeAndAlignmentFromType (ClangASTType &type)
52 m_size = type.GetByteSize();
54 uint32_t bit_alignment = type.GetTypeBitAlign();
56 if (bit_alignment % 8)
59 bit_alignment &= ~((uint32_t)0x111u);
62 m_alignment = bit_alignment / 8;
65 class EntityPersistentVariable : public Materializer::Entity
68 EntityPersistentVariable (lldb::ClangExpressionVariableSP &persistent_variable_sp) :
70 m_persistent_variable_sp(persistent_variable_sp)
72 // Hard-coding to maximum size of a pointer since persistent variables are materialized by reference
77 void MakeAllocation (IRMemoryMap &map, Error &err)
79 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
81 // Allocate a spare memory area to store the persistent variable's contents.
85 lldb::addr_t mem = map.Malloc(m_persistent_variable_sp->GetByteSize(),
87 lldb::ePermissionsReadable | lldb::ePermissionsWritable,
88 IRMemoryMap::eAllocationPolicyMirror,
91 if (!allocate_error.Success())
93 err.SetErrorStringWithFormat("couldn't allocate a memory area to store %s: %s", m_persistent_variable_sp->GetName().GetCString(), allocate_error.AsCString());
98 log->Printf("Allocated %s (0x%" PRIx64 ") sucessfully", m_persistent_variable_sp->GetName().GetCString(), mem);
100 // Put the location of the spare memory into the live data of the ValueObject.
102 m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create (map.GetBestExecutionContextScope(),
103 m_persistent_variable_sp->GetTypeFromUser(),
104 m_persistent_variable_sp->GetName(),
107 m_persistent_variable_sp->GetByteSize());
109 // Clear the flag if the variable will never be deallocated.
111 if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVKeepInTarget)
114 map.Leak(mem, leak_error);
115 m_persistent_variable_sp->m_flags &= ~ClangExpressionVariable::EVNeedsAllocation;
118 // Write the contents of the variable to the area.
122 map.WriteMemory (mem,
123 m_persistent_variable_sp->GetValueBytes(),
124 m_persistent_variable_sp->GetByteSize(),
127 if (!write_error.Success())
129 err.SetErrorStringWithFormat ("couldn't write %s to the target: %s", m_persistent_variable_sp->GetName().AsCString(),
130 write_error.AsCString());
135 void DestroyAllocation (IRMemoryMap &map, Error &err)
137 Error deallocate_error;
139 map.Free((lldb::addr_t)m_persistent_variable_sp->m_live_sp->GetValue().GetScalar().ULongLong(), deallocate_error);
141 m_persistent_variable_sp->m_live_sp.reset();
143 if (!deallocate_error.Success())
145 err.SetErrorStringWithFormat ("couldn't deallocate memory for %s: %s", m_persistent_variable_sp->GetName().GetCString(), deallocate_error.AsCString());
149 void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
151 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
153 const lldb::addr_t load_addr = process_address + m_offset;
157 log->Printf("EntityPersistentVariable::Materialize [address = 0x%" PRIx64 ", m_name = %s, m_flags = 0x%hx]",
159 m_persistent_variable_sp->GetName().AsCString(),
160 m_persistent_variable_sp->m_flags);
163 if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVNeedsAllocation)
165 MakeAllocation(map, err);
166 m_persistent_variable_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
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)
177 map.WriteScalarToMemory(load_addr,
178 m_persistent_variable_sp->m_live_sp->GetValue().GetScalar(),
179 map.GetAddressByteSize(),
182 if (!write_error.Success())
184 err.SetErrorStringWithFormat("couldn't write the location of %s to memory: %s", m_persistent_variable_sp->GetName().AsCString(), write_error.AsCString());
189 err.SetErrorStringWithFormat("no materialization happened for persistent variable %s", m_persistent_variable_sp->GetName().AsCString());
194 void Dematerialize (lldb::StackFrameSP &frame_sp,
196 lldb::addr_t process_address,
197 lldb::addr_t frame_top,
198 lldb::addr_t frame_bottom,
201 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
203 const lldb::addr_t load_addr = process_address + m_offset;
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);
213 if ((m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVIsLLDBAllocated) ||
214 (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVIsProgramReference))
216 if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVIsProgramReference &&
217 !m_persistent_variable_sp->m_live_sp)
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.
222 lldb::addr_t location;
225 map.ReadPointerFromMemory(&location, load_addr, read_error);
227 if (!read_error.Success())
229 err.SetErrorStringWithFormat("couldn't read the address of program-allocated variable %s: %s", m_persistent_variable_sp->GetName().GetCString(), read_error.AsCString());
233 m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create (map.GetBestExecutionContextScope (),
234 m_persistent_variable_sp->GetTypeFromUser(),
235 m_persistent_variable_sp->GetName(),
238 m_persistent_variable_sp->GetByteSize());
240 if (frame_top != LLDB_INVALID_ADDRESS &&
241 frame_bottom != LLDB_INVALID_ADDRESS &&
242 location >= frame_bottom &&
243 location <= frame_top)
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
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;
255 lldb::addr_t mem = m_persistent_variable_sp->m_live_sp->GetValue().GetScalar().ULongLong();
257 if (!m_persistent_variable_sp->m_live_sp)
259 err.SetErrorStringWithFormat("couldn't find the memory area used to store %s", m_persistent_variable_sp->GetName().GetCString());
263 if (m_persistent_variable_sp->m_live_sp->GetValue().GetValueAddressType() != eAddressTypeLoad)
265 err.SetErrorStringWithFormat("the address of the memory area for %s is in an incorrect format", m_persistent_variable_sp->GetName().GetCString());
269 if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVNeedsFreezeDry ||
270 m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVKeepInTarget)
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());
275 // Read the contents of the spare memory area
277 m_persistent_variable_sp->ValueUpdated ();
281 map.ReadMemory(m_persistent_variable_sp->GetValueBytes(),
283 m_persistent_variable_sp->GetByteSize(),
286 if (!read_error.Success())
288 err.SetErrorStringWithFormat ("couldn't read the contents of %s from memory: %s", m_persistent_variable_sp->GetName().GetCString(), read_error.AsCString());
292 m_persistent_variable_sp->m_flags &= ~ClangExpressionVariable::EVNeedsFreezeDry;
297 err.SetErrorStringWithFormat("no dematerialization happened for persistent variable %s", m_persistent_variable_sp->GetName().AsCString());
301 lldb::ProcessSP process_sp = map.GetBestExecutionContextScope()->CalculateProcess();
303 !process_sp->CanJIT())
305 // Allocations are not persistent so persistent variables cannot stay materialized.
307 m_persistent_variable_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
309 DestroyAllocation(map, err);
313 else if (m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVNeedsAllocation &&
314 !(m_persistent_variable_sp->m_flags & ClangExpressionVariable::EVKeepInTarget))
316 DestroyAllocation(map, err);
322 void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
324 StreamString dump_stream;
328 const lldb::addr_t load_addr = process_address + m_offset;
330 dump_stream.Printf("0x%" PRIx64 ": EntityPersistentVariable (%s)\n", load_addr, m_persistent_variable_sp->GetName().AsCString());
333 dump_stream.Printf("Pointer:\n");
335 DataBufferHeap data (m_size, 0);
337 map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
341 dump_stream.Printf(" <could not be read>\n");
345 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
347 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
349 dump_stream.PutChar('\n');
354 dump_stream.Printf("Target:\n");
356 lldb::addr_t target_address;
358 map.ReadPointerFromMemory (&target_address, load_addr, err);
362 dump_stream.Printf(" <could not be read>\n");
366 DataBufferHeap data (m_persistent_variable_sp->GetByteSize(), 0);
368 map.ReadMemory(data.GetBytes(), target_address, m_persistent_variable_sp->GetByteSize(), err);
372 dump_stream.Printf(" <could not be read>\n");
376 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
378 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, target_address);
380 dump_stream.PutChar('\n');
385 log->PutCString(dump_stream.GetData());
388 void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
392 lldb::ClangExpressionVariableSP m_persistent_variable_sp;
396 Materializer::AddPersistentVariable (lldb::ClangExpressionVariableSP &persistent_variable_sp, Error &err)
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);
405 class EntityVariable : public Materializer::Entity
408 EntityVariable (lldb::VariableSP &variable_sp) :
410 m_variable_sp(variable_sp),
411 m_is_reference(false),
412 m_temporary_allocation(LLDB_INVALID_ADDRESS),
413 m_temporary_allocation_size(0)
415 // Hard-coding to maximum size of a pointer since all variables are materialized by reference
418 m_is_reference = m_variable_sp->GetType()->GetClangForwardType().IsReferenceType();
421 void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
423 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
425 const lldb::addr_t load_addr = process_address + m_offset;
428 log->Printf("EntityVariable::Materialize [address = 0x%" PRIx64 ", m_variable_sp = %s]",
430 m_variable_sp->GetName().AsCString());
433 ExecutionContextScope *scope = frame_sp.get();
436 scope = map.GetBestExecutionContextScope();
438 lldb::ValueObjectSP valobj_sp = ValueObjectVariable::Create(scope, m_variable_sp);
442 err.SetErrorStringWithFormat("couldn't get a value object for variable %s", m_variable_sp->GetName().AsCString());
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);
454 map.WritePointerToMemory(load_addr, reference_addr, write_error);
456 if (!write_error.Success())
458 err.SetErrorStringWithFormat("couldn't write the contents of reference variable %s to memory: %s", m_variable_sp->GetName().AsCString(), write_error.AsCString());
464 AddressType address_type = eAddressTypeInvalid;
465 const bool scalar_is_load_address = false;
466 lldb::addr_t addr_of_valobj = valobj_sp->GetAddressOf(scalar_is_load_address, &address_type);
467 if (addr_of_valobj != LLDB_INVALID_ADDRESS)
470 map.WritePointerToMemory(load_addr, addr_of_valobj, write_error);
472 if (!write_error.Success())
474 err.SetErrorStringWithFormat("couldn't write the address of variable %s to memory: %s", m_variable_sp->GetName().AsCString(), write_error.AsCString());
481 valobj_sp->GetData(data);
483 if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
485 err.SetErrorStringWithFormat("trying to create a temporary region for %s but one exists", m_variable_sp->GetName().AsCString());
489 if (data.GetByteSize() != m_variable_sp->GetType()->GetByteSize())
491 if (data.GetByteSize() == 0 && m_variable_sp->LocationExpression().IsValid() == false)
493 err.SetErrorStringWithFormat("the variable '%s' has no location, it may have been optimized out", m_variable_sp->GetName().AsCString());
497 err.SetErrorStringWithFormat("size of variable %s (%" PRIu64 ") disagrees with the ValueObject's size (%" PRIu64 ")",
498 m_variable_sp->GetName().AsCString(),
499 m_variable_sp->GetType()->GetByteSize(),
505 size_t bit_align = m_variable_sp->GetType()->GetClangLayoutType().GetTypeBitAlign();
506 size_t byte_align = (bit_align + 7) / 8;
513 m_temporary_allocation = map.Malloc(data.GetByteSize(), byte_align, lldb::ePermissionsReadable | lldb::ePermissionsWritable, IRMemoryMap::eAllocationPolicyMirror, alloc_error);
514 m_temporary_allocation_size = data.GetByteSize();
516 if (!alloc_error.Success())
518 err.SetErrorStringWithFormat("couldn't allocate a temporary region for %s: %s", m_variable_sp->GetName().AsCString(), alloc_error.AsCString());
524 map.WriteMemory(m_temporary_allocation, data.GetDataStart(), data.GetByteSize(), write_error);
526 if (!write_error.Success())
528 err.SetErrorStringWithFormat("couldn't write to the temporary region for %s: %s", m_variable_sp->GetName().AsCString(), write_error.AsCString());
532 Error pointer_write_error;
534 map.WritePointerToMemory(load_addr, m_temporary_allocation, pointer_write_error);
536 if (!pointer_write_error.Success())
538 err.SetErrorStringWithFormat("couldn't write the address of the temporary region for %s: %s", m_variable_sp->GetName().AsCString(), pointer_write_error.AsCString());
544 void Dematerialize (lldb::StackFrameSP &frame_sp,
546 lldb::addr_t process_address,
547 lldb::addr_t frame_top,
548 lldb::addr_t frame_bottom,
551 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
553 const lldb::addr_t load_addr = process_address + m_offset;
556 log->Printf("EntityVariable::Dematerialize [address = 0x%" PRIx64 ", m_variable_sp = %s]",
558 m_variable_sp->GetName().AsCString());
561 if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
563 ExecutionContextScope *scope = frame_sp.get();
566 scope = map.GetBestExecutionContextScope();
568 lldb::ValueObjectSP valobj_sp = ValueObjectVariable::Create(scope, m_variable_sp);
572 err.SetErrorStringWithFormat("couldn't get a value object for variable %s", m_variable_sp->GetName().AsCString());
576 lldb_private::DataExtractor data;
580 map.GetMemoryData(data, m_temporary_allocation, valobj_sp->GetByteSize(), extract_error);
582 if (!extract_error.Success())
584 err.SetErrorStringWithFormat("couldn't get the data for variable %s", m_variable_sp->GetName().AsCString());
590 valobj_sp->SetData(data, set_error);
592 if (!set_error.Success())
594 err.SetErrorStringWithFormat("couldn't write the new contents of %s back into the variable", m_variable_sp->GetName().AsCString());
600 map.Free(m_temporary_allocation, free_error);
602 if (!free_error.Success())
604 err.SetErrorStringWithFormat("couldn't free the temporary region for %s: %s", m_variable_sp->GetName().AsCString(), free_error.AsCString());
608 m_temporary_allocation = LLDB_INVALID_ADDRESS;
609 m_temporary_allocation_size = 0;
613 void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
615 StreamString dump_stream;
617 const lldb::addr_t load_addr = process_address + m_offset;
618 dump_stream.Printf("0x%" PRIx64 ": EntityVariable\n", load_addr);
622 lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
625 dump_stream.Printf("Pointer:\n");
627 DataBufferHeap data (m_size, 0);
629 map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
633 dump_stream.Printf(" <could not be read>\n");
637 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
639 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
641 lldb::offset_t offset;
643 ptr = extractor.GetPointer(&offset);
645 dump_stream.PutChar('\n');
649 if (m_temporary_allocation == LLDB_INVALID_ADDRESS)
651 dump_stream.Printf("Points to process memory:\n");
655 dump_stream.Printf("Temporary allocation:\n");
658 if (ptr == LLDB_INVALID_ADDRESS)
660 dump_stream.Printf(" <could not be be found>\n");
664 DataBufferHeap data (m_temporary_allocation_size, 0);
666 map.ReadMemory(data.GetBytes(), m_temporary_allocation, m_temporary_allocation_size, err);
670 dump_stream.Printf(" <could not be read>\n");
674 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
676 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
678 dump_stream.PutChar('\n');
682 log->PutCString(dump_stream.GetData());
685 void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
687 if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
691 map.Free(m_temporary_allocation, free_error);
693 m_temporary_allocation = LLDB_INVALID_ADDRESS;
694 m_temporary_allocation_size = 0;
699 lldb::VariableSP m_variable_sp;
701 lldb::addr_t m_temporary_allocation;
702 size_t m_temporary_allocation_size;
706 Materializer::AddVariable (lldb::VariableSP &variable_sp, Error &err)
708 EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
709 iter->reset (new EntityVariable (variable_sp));
710 uint32_t ret = AddStructMember(**iter);
711 (*iter)->SetOffset(ret);
715 class EntityResultVariable : public Materializer::Entity
718 EntityResultVariable (const TypeFromUser &type, bool is_program_reference, bool keep_in_memory) :
721 m_is_program_reference(is_program_reference),
722 m_keep_in_memory(keep_in_memory),
723 m_temporary_allocation(LLDB_INVALID_ADDRESS),
724 m_temporary_allocation_size(0)
726 // Hard-coding to maximum size of a pointer since all results are materialized by reference
731 void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
733 if (!m_is_program_reference)
735 if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
737 err.SetErrorString("Trying to create a temporary region for the result but one exists");
741 const lldb::addr_t load_addr = process_address + m_offset;
743 size_t byte_size = m_type.GetByteSize();
744 size_t bit_align = m_type.GetTypeBitAlign();
745 size_t byte_align = (bit_align + 7) / 8;
752 m_temporary_allocation = map.Malloc(byte_size, byte_align, lldb::ePermissionsReadable | lldb::ePermissionsWritable, IRMemoryMap::eAllocationPolicyMirror, alloc_error);
753 m_temporary_allocation_size = byte_size;
755 if (!alloc_error.Success())
757 err.SetErrorStringWithFormat("couldn't allocate a temporary region for the result: %s", alloc_error.AsCString());
761 Error pointer_write_error;
763 map.WritePointerToMemory(load_addr, m_temporary_allocation, pointer_write_error);
765 if (!pointer_write_error.Success())
767 err.SetErrorStringWithFormat("couldn't write the address of the temporary region for the result: %s", pointer_write_error.AsCString());
772 void Dematerialize (lldb::StackFrameSP &frame_sp,
774 lldb::addr_t process_address,
775 lldb::addr_t frame_top,
776 lldb::addr_t frame_bottom,
779 err.SetErrorString("Tried to detmaterialize a result variable with the normal Dematerialize method");
782 void Dematerialize (lldb::ClangExpressionVariableSP &result_variable_sp,
783 lldb::StackFrameSP &frame_sp,
785 lldb::addr_t process_address,
786 lldb::addr_t frame_top,
787 lldb::addr_t frame_bottom,
792 ExecutionContextScope *exe_scope = map.GetBestExecutionContextScope();
796 err.SetErrorString("Couldn't dematerialize a result variable: invalid execution context scope");
800 lldb::addr_t address;
802 const lldb::addr_t load_addr = process_address + m_offset;
804 map.ReadPointerFromMemory (&address, load_addr, read_error);
806 if (!read_error.Success())
808 err.SetErrorString("Couldn't dematerialize a result variable: couldn't read its address");
812 lldb::TargetSP target_sp = exe_scope->CalculateTarget();
816 err.SetErrorString("Couldn't dematerialize a result variable: no target");
820 ConstString name = target_sp->GetPersistentVariables().GetNextPersistentVariableName();
822 lldb::ClangExpressionVariableSP ret;
824 ret = target_sp->GetPersistentVariables().CreateVariable(exe_scope,
828 map.GetAddressByteSize());
832 err.SetErrorStringWithFormat("couldn't dematerialize a result variable: failed to make persistent variable %s", name.AsCString());
836 lldb::ProcessSP process_sp = map.GetBestExecutionContextScope()->CalculateProcess();
838 bool can_persist = (m_is_program_reference && process_sp && process_sp->CanJIT() && !(address >= frame_bottom && address < frame_top));
840 if (can_persist && m_keep_in_memory)
842 ret->m_live_sp = ValueObjectConstResult::Create(exe_scope,
847 map.GetAddressByteSize());
852 const size_t pvar_byte_size = ret->GetByteSize();
853 uint8_t *pvar_data = ret->GetValueBytes();
855 map.ReadMemory(pvar_data, address, pvar_byte_size, read_error);
857 if (!read_error.Success())
859 err.SetErrorString("Couldn't dematerialize a result variable: couldn't read its memory");
863 result_variable_sp = ret;
865 if (!can_persist || !m_keep_in_memory)
867 ret->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
869 if (m_temporary_allocation != LLDB_INVALID_ADDRESS)
872 map.Free(m_temporary_allocation, free_error);
877 ret->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
880 m_temporary_allocation = LLDB_INVALID_ADDRESS;
881 m_temporary_allocation_size = 0;
884 void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
886 StreamString dump_stream;
888 const lldb::addr_t load_addr = process_address + m_offset;
890 dump_stream.Printf("0x%" PRIx64 ": EntityResultVariable\n", load_addr);
894 lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
897 dump_stream.Printf("Pointer:\n");
899 DataBufferHeap data (m_size, 0);
901 map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
905 dump_stream.Printf(" <could not be read>\n");
909 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
911 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
913 lldb::offset_t offset;
915 ptr = extractor.GetPointer(&offset);
917 dump_stream.PutChar('\n');
921 if (m_temporary_allocation == LLDB_INVALID_ADDRESS)
923 dump_stream.Printf("Points to process memory:\n");
927 dump_stream.Printf("Temporary allocation:\n");
930 if (ptr == LLDB_INVALID_ADDRESS)
932 dump_stream.Printf(" <could not be be found>\n");
936 DataBufferHeap data (m_temporary_allocation_size, 0);
938 map.ReadMemory(data.GetBytes(), m_temporary_allocation, m_temporary_allocation_size, err);
942 dump_stream.Printf(" <could not be read>\n");
946 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
948 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
950 dump_stream.PutChar('\n');
954 log->PutCString(dump_stream.GetData());
957 void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
959 if (!m_keep_in_memory && m_temporary_allocation != LLDB_INVALID_ADDRESS)
963 map.Free(m_temporary_allocation, free_error);
966 m_temporary_allocation = LLDB_INVALID_ADDRESS;
967 m_temporary_allocation_size = 0;
971 bool m_is_program_reference;
972 bool m_keep_in_memory;
974 lldb::addr_t m_temporary_allocation;
975 size_t m_temporary_allocation_size;
979 Materializer::AddResultVariable (const TypeFromUser &type, bool is_program_reference, bool keep_in_memory, Error &err)
981 EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
982 iter->reset (new EntityResultVariable (type, is_program_reference, keep_in_memory));
983 uint32_t ret = AddStructMember(**iter);
984 (*iter)->SetOffset(ret);
985 m_result_entity = iter->get();
989 class EntitySymbol : public Materializer::Entity
992 EntitySymbol (const Symbol &symbol) :
996 // Hard-coding to maximum size of a symbol
1001 void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
1003 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1005 const lldb::addr_t load_addr = process_address + m_offset;
1009 log->Printf("EntitySymbol::Materialize [address = 0x%" PRIx64 ", m_symbol = %s]",
1010 (uint64_t)load_addr,
1011 m_symbol.GetName().AsCString());
1014 Address &sym_address = m_symbol.GetAddress();
1016 ExecutionContextScope *exe_scope = map.GetBestExecutionContextScope();
1018 lldb::TargetSP target_sp;
1021 target_sp = map.GetBestExecutionContextScope()->CalculateTarget();
1025 err.SetErrorStringWithFormat("couldn't resolve symbol %s because there is no target", m_symbol.GetName().AsCString());
1029 lldb::addr_t resolved_address = sym_address.GetLoadAddress(target_sp.get());
1031 if (resolved_address == LLDB_INVALID_ADDRESS)
1032 resolved_address = sym_address.GetFileAddress();
1034 Error pointer_write_error;
1036 map.WritePointerToMemory(load_addr, resolved_address, pointer_write_error);
1038 if (!pointer_write_error.Success())
1040 err.SetErrorStringWithFormat("couldn't write the address of symbol %s: %s", m_symbol.GetName().AsCString(), pointer_write_error.AsCString());
1045 void Dematerialize (lldb::StackFrameSP &frame_sp,
1047 lldb::addr_t process_address,
1048 lldb::addr_t frame_top,
1049 lldb::addr_t frame_bottom,
1052 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1054 const lldb::addr_t load_addr = process_address + m_offset;
1058 log->Printf("EntitySymbol::Dematerialize [address = 0x%" PRIx64 ", m_symbol = %s]",
1059 (uint64_t)load_addr,
1060 m_symbol.GetName().AsCString());
1063 // no work needs to be done
1066 void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
1068 StreamString dump_stream;
1072 const lldb::addr_t load_addr = process_address + m_offset;
1074 dump_stream.Printf("0x%" PRIx64 ": EntitySymbol (%s)\n", load_addr, m_symbol.GetName().AsCString());
1077 dump_stream.Printf("Pointer:\n");
1079 DataBufferHeap data (m_size, 0);
1081 map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
1085 dump_stream.Printf(" <could not be read>\n");
1089 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
1091 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
1093 dump_stream.PutChar('\n');
1097 log->PutCString(dump_stream.GetData());
1100 void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
1108 Materializer::AddSymbol (const Symbol &symbol_sp, Error &err)
1110 EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
1111 iter->reset (new EntitySymbol (symbol_sp));
1112 uint32_t ret = AddStructMember(**iter);
1113 (*iter)->SetOffset(ret);
1117 class EntityRegister : public Materializer::Entity
1120 EntityRegister (const RegisterInfo ®ister_info) :
1122 m_register_info(register_info)
1124 // Hard-coding alignment conservatively
1125 m_size = m_register_info.byte_size;
1126 m_alignment = m_register_info.byte_size;
1129 void Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err)
1131 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1133 const lldb::addr_t load_addr = process_address + m_offset;
1137 log->Printf("EntityRegister::Materialize [address = 0x%" PRIx64 ", m_register_info = %s]",
1138 (uint64_t)load_addr,
1139 m_register_info.name);
1142 RegisterValue reg_value;
1144 if (!frame_sp.get())
1146 err.SetErrorStringWithFormat("couldn't materialize register %s without a stack frame", m_register_info.name);
1150 lldb::RegisterContextSP reg_context_sp = frame_sp->GetRegisterContext();
1152 if (!reg_context_sp->ReadRegister(&m_register_info, reg_value))
1154 err.SetErrorStringWithFormat("couldn't read the value of register %s", m_register_info.name);
1158 DataExtractor register_data;
1160 if (!reg_value.GetData(register_data))
1162 err.SetErrorStringWithFormat("couldn't get the data for register %s", m_register_info.name);
1166 if (register_data.GetByteSize() != m_register_info.byte_size)
1168 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);
1172 m_register_contents.reset(new DataBufferHeap(register_data.GetDataStart(), register_data.GetByteSize()));
1176 map.WriteMemory(load_addr, register_data.GetDataStart(), register_data.GetByteSize(), write_error);
1178 if (!write_error.Success())
1180 err.SetErrorStringWithFormat("couldn't write the contents of register %s: %s", m_register_info.name, write_error.AsCString());
1185 void Dematerialize (lldb::StackFrameSP &frame_sp,
1187 lldb::addr_t process_address,
1188 lldb::addr_t frame_top,
1189 lldb::addr_t frame_bottom,
1192 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1194 const lldb::addr_t load_addr = process_address + m_offset;
1198 log->Printf("EntityRegister::Dematerialize [address = 0x%" PRIx64 ", m_register_info = %s]",
1199 (uint64_t)load_addr,
1200 m_register_info.name);
1203 Error extract_error;
1205 DataExtractor register_data;
1207 if (!frame_sp.get())
1209 err.SetErrorStringWithFormat("couldn't dematerialize register %s without a stack frame", m_register_info.name);
1213 lldb::RegisterContextSP reg_context_sp = frame_sp->GetRegisterContext();
1215 map.GetMemoryData(register_data, load_addr, m_register_info.byte_size, extract_error);
1217 if (!extract_error.Success())
1219 err.SetErrorStringWithFormat("couldn't get the data for register %s: %s", m_register_info.name, extract_error.AsCString());
1223 if (!memcmp(register_data.GetDataStart(), m_register_contents->GetBytes(), register_data.GetByteSize()))
1225 // No write required, and in particular we avoid errors if the register wasn't writable
1227 m_register_contents.reset();
1231 m_register_contents.reset();
1233 RegisterValue register_value (const_cast<uint8_t*>(register_data.GetDataStart()), register_data.GetByteSize(), register_data.GetByteOrder());
1235 if (!reg_context_sp->WriteRegister(&m_register_info, register_value))
1237 err.SetErrorStringWithFormat("couldn't write the value of register %s", m_register_info.name);
1242 void DumpToLog (IRMemoryMap &map, lldb::addr_t process_address, Log *log)
1244 StreamString dump_stream;
1248 const lldb::addr_t load_addr = process_address + m_offset;
1251 dump_stream.Printf("0x%" PRIx64 ": EntityRegister (%s)\n", load_addr, m_register_info.name);
1254 dump_stream.Printf("Value:\n");
1256 DataBufferHeap data (m_size, 0);
1258 map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
1262 dump_stream.Printf(" <could not be read>\n");
1266 DataExtractor extractor (data.GetBytes(), data.GetByteSize(), map.GetByteOrder(), map.GetAddressByteSize());
1268 extractor.DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16, load_addr);
1270 dump_stream.PutChar('\n');
1274 log->PutCString(dump_stream.GetData());
1277 void Wipe (IRMemoryMap &map, lldb::addr_t process_address)
1281 RegisterInfo m_register_info;
1282 lldb::DataBufferSP m_register_contents;
1286 Materializer::AddRegister (const RegisterInfo ®ister_info, Error &err)
1288 EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
1289 iter->reset (new EntityRegister (register_info));
1290 uint32_t ret = AddStructMember(**iter);
1291 (*iter)->SetOffset(ret);
1295 Materializer::Materializer () :
1296 m_dematerializer_wp(),
1297 m_result_entity(NULL),
1298 m_current_offset(0),
1299 m_struct_alignment(8)
1303 Materializer::~Materializer ()
1305 DematerializerSP dematerializer_sp = m_dematerializer_wp.lock();
1307 if (dematerializer_sp)
1308 dematerializer_sp->Wipe();
1311 Materializer::DematerializerSP
1312 Materializer::Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &error)
1314 ExecutionContextScope *exe_scope = frame_sp.get();
1317 exe_scope = map.GetBestExecutionContextScope();
1319 DematerializerSP dematerializer_sp = m_dematerializer_wp.lock();
1321 if (dematerializer_sp)
1323 error.SetErrorToGenericError();
1324 error.SetErrorString("Couldn't materialize: already materialized");
1327 DematerializerSP ret(new Dematerializer(*this, frame_sp, map, process_address));
1331 error.SetErrorToGenericError();
1332 error.SetErrorString("Couldn't materialize: target doesn't exist");
1335 for (EntityUP &entity_up : m_entities)
1337 entity_up->Materialize(frame_sp, map, process_address, error);
1339 if (!error.Success())
1340 return DematerializerSP();
1343 if (Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
1345 log->Printf("Materializer::Materialize (frame_sp = %p, process_address = 0x%" PRIx64 ") materialized:", frame_sp.get(), process_address);
1346 for (EntityUP &entity_up : m_entities)
1347 entity_up->DumpToLog(map, process_address, log);
1350 m_dematerializer_wp = ret;
1356 Materializer::Dematerializer::Dematerialize (Error &error, lldb::ClangExpressionVariableSP &result_sp, lldb::addr_t frame_bottom, lldb::addr_t frame_top)
1358 lldb::StackFrameSP frame_sp;
1360 lldb::ThreadSP thread_sp = m_thread_wp.lock();
1362 frame_sp = thread_sp->GetFrameWithStackID(m_stack_id);
1364 ExecutionContextScope *exe_scope = m_map->GetBestExecutionContextScope();
1368 error.SetErrorToGenericError();
1369 error.SetErrorString("Couldn't dematerialize: invalid dematerializer");
1374 error.SetErrorToGenericError();
1375 error.SetErrorString("Couldn't dematerialize: target is gone");
1379 if (Log *log =lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
1381 log->Printf("Materializer::Dematerialize (frame_sp = %p, process_address = 0x%" PRIx64 ") about to dematerialize:", frame_sp.get(), m_process_address);
1382 for (EntityUP &entity_up : m_materializer->m_entities)
1383 entity_up->DumpToLog(*m_map, m_process_address, log);
1386 for (EntityUP &entity_up : m_materializer->m_entities)
1388 if (entity_up.get() == m_materializer->m_result_entity)
1390 static_cast<EntityResultVariable*>(m_materializer->m_result_entity)->Dematerialize (result_sp, frame_sp, *m_map, m_process_address, frame_top, frame_bottom, error);
1394 entity_up->Dematerialize (frame_sp, *m_map, m_process_address, frame_top, frame_bottom, error);
1397 if (!error.Success())
1406 Materializer::Dematerializer::Wipe ()
1411 for (EntityUP &entity_up : m_materializer->m_entities)
1413 entity_up->Wipe (*m_map, m_process_address);
1416 m_materializer = NULL;
1418 m_process_address = LLDB_INVALID_ADDRESS;