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