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