xref: /freebsd-src/contrib/llvm-project/lldb/source/Core/Value.cpp (revision 0b57cec536236d46e3dba9bd041533462f33dbb7) 
1 //===-- Value.cpp -----------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Core/Value.h"
10 
11 #include "lldb/Core/Address.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Symbol/CompilerType.h"
14 #include "lldb/Symbol/ObjectFile.h"
15 #include "lldb/Symbol/SymbolContext.h"
16 #include "lldb/Symbol/Type.h"
17 #include "lldb/Symbol/Variable.h"
18 #include "lldb/Target/ExecutionContext.h"
19 #include "lldb/Target/Process.h"
20 #include "lldb/Target/SectionLoadList.h"
21 #include "lldb/Target/Target.h"
22 #include "lldb/Utility/ConstString.h"
23 #include "lldb/Utility/DataBufferHeap.h"
24 #include "lldb/Utility/DataExtractor.h"
25 #include "lldb/Utility/Endian.h"
26 #include "lldb/Utility/FileSpec.h"
27 #include "lldb/Utility/State.h"
28 #include "lldb/Utility/Stream.h"
29 #include "lldb/lldb-defines.h"
30 #include "lldb/lldb-forward.h"
31 #include "lldb/lldb-types.h"
32 
33 #include <memory>
34 #include <string>
35 
36 #include <inttypes.h>
37 
38 using namespace lldb;
39 using namespace lldb_private;
40 
41 Value::Value()
42     : m_value(), m_vector(), m_compiler_type(), m_context(nullptr),
43       m_value_type(eValueTypeScalar), m_context_type(eContextTypeInvalid),
44       m_data_buffer() {}
45 
46 Value::Value(const Scalar &scalar)
47     : m_value(scalar), m_vector(), m_compiler_type(), m_context(nullptr),
48       m_value_type(eValueTypeScalar), m_context_type(eContextTypeInvalid),
49       m_data_buffer() {}
50 
51 Value::Value(const void *bytes, int len)
52     : m_value(), m_vector(), m_compiler_type(), m_context(nullptr),
53       m_value_type(eValueTypeHostAddress), m_context_type(eContextTypeInvalid),
54       m_data_buffer() {
55   SetBytes(bytes, len);
56 }
57 
58 Value::Value(const Value &v)
59     : m_value(v.m_value), m_vector(v.m_vector),
60       m_compiler_type(v.m_compiler_type), m_context(v.m_context),
61       m_value_type(v.m_value_type), m_context_type(v.m_context_type),
62       m_data_buffer() {
63   const uintptr_t rhs_value =
64       (uintptr_t)v.m_value.ULongLong(LLDB_INVALID_ADDRESS);
65   if ((rhs_value != 0) &&
66       (rhs_value == (uintptr_t)v.m_data_buffer.GetBytes())) {
67     m_data_buffer.CopyData(v.m_data_buffer.GetBytes(),
68                            v.m_data_buffer.GetByteSize());
69 
70     m_value = (uintptr_t)m_data_buffer.GetBytes();
71   }
72 }
73 
74 Value &Value::operator=(const Value &rhs) {
75   if (this != &rhs) {
76     m_value = rhs.m_value;
77     m_vector = rhs.m_vector;
78     m_compiler_type = rhs.m_compiler_type;
79     m_context = rhs.m_context;
80     m_value_type = rhs.m_value_type;
81     m_context_type = rhs.m_context_type;
82     const uintptr_t rhs_value =
83         (uintptr_t)rhs.m_value.ULongLong(LLDB_INVALID_ADDRESS);
84     if ((rhs_value != 0) &&
85         (rhs_value == (uintptr_t)rhs.m_data_buffer.GetBytes())) {
86       m_data_buffer.CopyData(rhs.m_data_buffer.GetBytes(),
87                              rhs.m_data_buffer.GetByteSize());
88 
89       m_value = (uintptr_t)m_data_buffer.GetBytes();
90     }
91   }
92   return *this;
93 }
94 
95 void Value::SetBytes(const void *bytes, int len) {
96   m_value_type = eValueTypeHostAddress;
97   m_data_buffer.CopyData(bytes, len);
98   m_value = (uintptr_t)m_data_buffer.GetBytes();
99 }
100 
101 void Value::AppendBytes(const void *bytes, int len) {
102   m_value_type = eValueTypeHostAddress;
103   m_data_buffer.AppendData(bytes, len);
104   m_value = (uintptr_t)m_data_buffer.GetBytes();
105 }
106 
107 void Value::Dump(Stream *strm) {
108   m_value.GetValue(strm, true);
109   strm->Printf(", value_type = %s, context = %p, context_type = %s",
110                Value::GetValueTypeAsCString(m_value_type), m_context,
111                Value::GetContextTypeAsCString(m_context_type));
112 }
113 
114 Value::ValueType Value::GetValueType() const { return m_value_type; }
115 
116 AddressType Value::GetValueAddressType() const {
117   switch (m_value_type) {
118   default:
119   case eValueTypeScalar:
120     break;
121   case eValueTypeLoadAddress:
122     return eAddressTypeLoad;
123   case eValueTypeFileAddress:
124     return eAddressTypeFile;
125   case eValueTypeHostAddress:
126     return eAddressTypeHost;
127   }
128   return eAddressTypeInvalid;
129 }
130 
131 RegisterInfo *Value::GetRegisterInfo() const {
132   if (m_context_type == eContextTypeRegisterInfo)
133     return static_cast<RegisterInfo *>(m_context);
134   return nullptr;
135 }
136 
137 Type *Value::GetType() {
138   if (m_context_type == eContextTypeLLDBType)
139     return static_cast<Type *>(m_context);
140   return nullptr;
141 }
142 
143 size_t Value::AppendDataToHostBuffer(const Value &rhs) {
144   if (this == &rhs)
145     return 0;
146 
147   size_t curr_size = m_data_buffer.GetByteSize();
148   Status error;
149   switch (rhs.GetValueType()) {
150   case eValueTypeScalar: {
151     const size_t scalar_size = rhs.m_value.GetByteSize();
152     if (scalar_size > 0) {
153       const size_t new_size = curr_size + scalar_size;
154       if (ResizeData(new_size) == new_size) {
155         rhs.m_value.GetAsMemoryData(m_data_buffer.GetBytes() + curr_size,
156                                     scalar_size, endian::InlHostByteOrder(),
157                                     error);
158         return scalar_size;
159       }
160     }
161   } break;
162   case eValueTypeVector: {
163     const size_t vector_size = rhs.m_vector.length;
164     if (vector_size > 0) {
165       const size_t new_size = curr_size + vector_size;
166       if (ResizeData(new_size) == new_size) {
167         ::memcpy(m_data_buffer.GetBytes() + curr_size, rhs.m_vector.bytes,
168                  vector_size);
169         return vector_size;
170       }
171     }
172   } break;
173   case eValueTypeFileAddress:
174   case eValueTypeLoadAddress:
175   case eValueTypeHostAddress: {
176     const uint8_t *src = rhs.GetBuffer().GetBytes();
177     const size_t src_len = rhs.GetBuffer().GetByteSize();
178     if (src && src_len > 0) {
179       const size_t new_size = curr_size + src_len;
180       if (ResizeData(new_size) == new_size) {
181         ::memcpy(m_data_buffer.GetBytes() + curr_size, src, src_len);
182         return src_len;
183       }
184     }
185   } break;
186   }
187   return 0;
188 }
189 
190 size_t Value::ResizeData(size_t len) {
191   m_value_type = eValueTypeHostAddress;
192   m_data_buffer.SetByteSize(len);
193   m_value = (uintptr_t)m_data_buffer.GetBytes();
194   return m_data_buffer.GetByteSize();
195 }
196 
197 bool Value::ValueOf(ExecutionContext *exe_ctx) {
198   switch (m_context_type) {
199   case eContextTypeInvalid:
200   case eContextTypeRegisterInfo: // RegisterInfo *
201   case eContextTypeLLDBType:     // Type *
202     break;
203 
204   case eContextTypeVariable: // Variable *
205     ResolveValue(exe_ctx);
206     return true;
207   }
208   return false;
209 }
210 
211 uint64_t Value::GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx) {
212   switch (m_context_type) {
213   case eContextTypeRegisterInfo: // RegisterInfo *
214     if (GetRegisterInfo()) {
215       if (error_ptr)
216         error_ptr->Clear();
217       return GetRegisterInfo()->byte_size;
218     }
219     break;
220 
221   case eContextTypeInvalid:
222   case eContextTypeLLDBType: // Type *
223   case eContextTypeVariable: // Variable *
224   {
225     auto *scope = exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
226     if (llvm::Optional<uint64_t> size = GetCompilerType().GetByteSize(scope)) {
227       if (error_ptr)
228         error_ptr->Clear();
229       return *size;
230     }
231     break;
232   }
233   }
234   if (error_ptr && error_ptr->Success())
235     error_ptr->SetErrorString("Unable to determine byte size.");
236   return 0;
237 }
238 
239 const CompilerType &Value::GetCompilerType() {
240   if (!m_compiler_type.IsValid()) {
241     switch (m_context_type) {
242     case eContextTypeInvalid:
243       break;
244 
245     case eContextTypeRegisterInfo:
246       break; // TODO: Eventually convert into a compiler type?
247 
248     case eContextTypeLLDBType: {
249       Type *lldb_type = GetType();
250       if (lldb_type)
251         m_compiler_type = lldb_type->GetForwardCompilerType();
252     } break;
253 
254     case eContextTypeVariable: {
255       Variable *variable = GetVariable();
256       if (variable) {
257         Type *variable_type = variable->GetType();
258         if (variable_type)
259           m_compiler_type = variable_type->GetForwardCompilerType();
260       }
261     } break;
262     }
263   }
264 
265   return m_compiler_type;
266 }
267 
268 void Value::SetCompilerType(const CompilerType &compiler_type) {
269   m_compiler_type = compiler_type;
270 }
271 
272 lldb::Format Value::GetValueDefaultFormat() {
273   switch (m_context_type) {
274   case eContextTypeRegisterInfo:
275     if (GetRegisterInfo())
276       return GetRegisterInfo()->format;
277     break;
278 
279   case eContextTypeInvalid:
280   case eContextTypeLLDBType:
281   case eContextTypeVariable: {
282     const CompilerType &ast_type = GetCompilerType();
283     if (ast_type.IsValid())
284       return ast_type.GetFormat();
285   } break;
286   }
287 
288   // Return a good default in case we can't figure anything out
289   return eFormatHex;
290 }
291 
292 bool Value::GetData(DataExtractor &data) {
293   switch (m_value_type) {
294   default:
295     break;
296 
297   case eValueTypeScalar:
298     if (m_value.GetData(data))
299       return true;
300     break;
301 
302   case eValueTypeLoadAddress:
303   case eValueTypeFileAddress:
304   case eValueTypeHostAddress:
305     if (m_data_buffer.GetByteSize()) {
306       data.SetData(m_data_buffer.GetBytes(), m_data_buffer.GetByteSize(),
307                    data.GetByteOrder());
308       return true;
309     }
310     break;
311   }
312 
313   return false;
314 }
315 
316 Status Value::GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
317                              uint32_t data_offset, Module *module) {
318   data.Clear();
319 
320   Status error;
321   lldb::addr_t address = LLDB_INVALID_ADDRESS;
322   AddressType address_type = eAddressTypeFile;
323   Address file_so_addr;
324   const CompilerType &ast_type = GetCompilerType();
325   switch (m_value_type) {
326   case eValueTypeVector:
327     if (ast_type.IsValid())
328       data.SetAddressByteSize(ast_type.GetPointerByteSize());
329     else
330       data.SetAddressByteSize(sizeof(void *));
331     data.SetData(m_vector.bytes, m_vector.length, m_vector.byte_order);
332     break;
333 
334   case eValueTypeScalar: {
335     data.SetByteOrder(endian::InlHostByteOrder());
336     if (ast_type.IsValid())
337       data.SetAddressByteSize(ast_type.GetPointerByteSize());
338     else
339       data.SetAddressByteSize(sizeof(void *));
340 
341     uint32_t limit_byte_size = UINT32_MAX;
342 
343     if (llvm::Optional<uint64_t> size = ast_type.GetByteSize(
344             exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr))
345       limit_byte_size = *size;
346 
347     if (limit_byte_size <= m_value.GetByteSize()) {
348       if (m_value.GetData(data, limit_byte_size))
349         return error; // Success;
350     }
351 
352     error.SetErrorStringWithFormat("extracting data from value failed");
353     break;
354   }
355   case eValueTypeLoadAddress:
356     if (exe_ctx == nullptr) {
357       error.SetErrorString("can't read load address (no execution context)");
358     } else {
359       Process *process = exe_ctx->GetProcessPtr();
360       if (process == nullptr || !process->IsAlive()) {
361         Target *target = exe_ctx->GetTargetPtr();
362         if (target) {
363           // Allow expressions to run and evaluate things when the target has
364           // memory sections loaded. This allows you to use "target modules
365           // load" to load your executable and any shared libraries, then
366           // execute commands where you can look at types in data sections.
367           const SectionLoadList &target_sections = target->GetSectionLoadList();
368           if (!target_sections.IsEmpty()) {
369             address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
370             if (target_sections.ResolveLoadAddress(address, file_so_addr)) {
371               address_type = eAddressTypeLoad;
372               data.SetByteOrder(target->GetArchitecture().GetByteOrder());
373               data.SetAddressByteSize(
374                   target->GetArchitecture().GetAddressByteSize());
375             } else
376               address = LLDB_INVALID_ADDRESS;
377           }
378         } else {
379           error.SetErrorString("can't read load address (invalid process)");
380         }
381       } else {
382         address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
383         address_type = eAddressTypeLoad;
384         data.SetByteOrder(
385             process->GetTarget().GetArchitecture().GetByteOrder());
386         data.SetAddressByteSize(
387             process->GetTarget().GetArchitecture().GetAddressByteSize());
388       }
389     }
390     break;
391 
392   case eValueTypeFileAddress:
393     if (exe_ctx == nullptr) {
394       error.SetErrorString("can't read file address (no execution context)");
395     } else if (exe_ctx->GetTargetPtr() == nullptr) {
396       error.SetErrorString("can't read file address (invalid target)");
397     } else {
398       address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
399       if (address == LLDB_INVALID_ADDRESS) {
400         error.SetErrorString("invalid file address");
401       } else {
402         if (module == nullptr) {
403           // The only thing we can currently lock down to a module so that we
404           // can resolve a file address, is a variable.
405           Variable *variable = GetVariable();
406           if (variable) {
407             SymbolContext var_sc;
408             variable->CalculateSymbolContext(&var_sc);
409             module = var_sc.module_sp.get();
410           }
411         }
412 
413         if (module) {
414           bool resolved = false;
415           ObjectFile *objfile = module->GetObjectFile();
416           if (objfile) {
417             Address so_addr(address, objfile->GetSectionList());
418             addr_t load_address =
419                 so_addr.GetLoadAddress(exe_ctx->GetTargetPtr());
420             bool process_launched_and_stopped =
421                 exe_ctx->GetProcessPtr()
422                     ? StateIsStoppedState(exe_ctx->GetProcessPtr()->GetState(),
423                                           true /* must_exist */)
424                     : false;
425             // Don't use the load address if the process has exited.
426             if (load_address != LLDB_INVALID_ADDRESS &&
427                 process_launched_and_stopped) {
428               resolved = true;
429               address = load_address;
430               address_type = eAddressTypeLoad;
431               data.SetByteOrder(
432                   exe_ctx->GetTargetRef().GetArchitecture().GetByteOrder());
433               data.SetAddressByteSize(exe_ctx->GetTargetRef()
434                                           .GetArchitecture()
435                                           .GetAddressByteSize());
436             } else {
437               if (so_addr.IsSectionOffset()) {
438                 resolved = true;
439                 file_so_addr = so_addr;
440                 data.SetByteOrder(objfile->GetByteOrder());
441                 data.SetAddressByteSize(objfile->GetAddressByteSize());
442               }
443             }
444           }
445           if (!resolved) {
446             Variable *variable = GetVariable();
447 
448             if (module) {
449               if (variable)
450                 error.SetErrorStringWithFormat(
451                     "unable to resolve the module for file address 0x%" PRIx64
452                     " for variable '%s' in %s",
453                     address, variable->GetName().AsCString(""),
454                     module->GetFileSpec().GetPath().c_str());
455               else
456                 error.SetErrorStringWithFormat(
457                     "unable to resolve the module for file address 0x%" PRIx64
458                     " in %s",
459                     address, module->GetFileSpec().GetPath().c_str());
460             } else {
461               if (variable)
462                 error.SetErrorStringWithFormat(
463                     "unable to resolve the module for file address 0x%" PRIx64
464                     " for variable '%s'",
465                     address, variable->GetName().AsCString(""));
466               else
467                 error.SetErrorStringWithFormat(
468                     "unable to resolve the module for file address 0x%" PRIx64,
469                     address);
470             }
471           }
472         } else {
473           // Can't convert a file address to anything valid without more
474           // context (which Module it came from)
475           error.SetErrorString(
476               "can't read memory from file address without more context");
477         }
478       }
479     }
480     break;
481 
482   case eValueTypeHostAddress:
483     address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
484     address_type = eAddressTypeHost;
485     if (exe_ctx) {
486       Target *target = exe_ctx->GetTargetPtr();
487       if (target) {
488         data.SetByteOrder(target->GetArchitecture().GetByteOrder());
489         data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
490         break;
491       }
492     }
493     // fallback to host settings
494     data.SetByteOrder(endian::InlHostByteOrder());
495     data.SetAddressByteSize(sizeof(void *));
496     break;
497   }
498 
499   // Bail if we encountered any errors
500   if (error.Fail())
501     return error;
502 
503   if (address == LLDB_INVALID_ADDRESS) {
504     error.SetErrorStringWithFormat("invalid %s address",
505                                    address_type == eAddressTypeHost ? "host"
506                                                                     : "load");
507     return error;
508   }
509 
510   // If we got here, we need to read the value from memory
511   size_t byte_size = GetValueByteSize(&error, exe_ctx);
512 
513   // Bail if we encountered any errors getting the byte size
514   if (error.Fail())
515     return error;
516 
517   // No memory to read for zero-sized types.
518   if (byte_size == 0)
519     return error;
520 
521   // Make sure we have enough room within "data", and if we don't make
522   // something large enough that does
523   if (!data.ValidOffsetForDataOfSize(data_offset, byte_size)) {
524     auto data_sp =
525         std::make_shared<DataBufferHeap>(data_offset + byte_size, '\0');
526     data.SetData(data_sp);
527   }
528 
529   uint8_t *dst = const_cast<uint8_t *>(data.PeekData(data_offset, byte_size));
530   if (dst != nullptr) {
531     if (address_type == eAddressTypeHost) {
532       // The address is an address in this process, so just copy it.
533       if (address == 0) {
534         error.SetErrorStringWithFormat(
535             "trying to read from host address of 0.");
536         return error;
537       }
538       memcpy(dst, reinterpret_cast<uint8_t *>(address), byte_size);
539     } else if ((address_type == eAddressTypeLoad) ||
540                (address_type == eAddressTypeFile)) {
541       if (file_so_addr.IsValid()) {
542         // We have a file address that we were able to translate into a section
543         // offset address so we might be able to read this from the object
544         // files if we don't have a live process. Lets always try and read from
545         // the process if we have one though since we want to read the actual
546         // value by setting "prefer_file_cache" to false.
547         const bool prefer_file_cache = false;
548         if (exe_ctx->GetTargetRef().ReadMemory(file_so_addr, prefer_file_cache,
549                                                dst, byte_size,
550                                                error) != byte_size) {
551           error.SetErrorStringWithFormat(
552               "read memory from 0x%" PRIx64 " failed", (uint64_t)address);
553         }
554       } else {
555         // The execution context might have a NULL process, but it might have a
556         // valid process in the exe_ctx->target, so use the
557         // ExecutionContext::GetProcess accessor to ensure we get the process
558         // if there is one.
559         Process *process = exe_ctx->GetProcessPtr();
560 
561         if (process) {
562           const size_t bytes_read =
563               process->ReadMemory(address, dst, byte_size, error);
564           if (bytes_read != byte_size)
565             error.SetErrorStringWithFormat(
566                 "read memory from 0x%" PRIx64 " failed (%u of %u bytes read)",
567                 (uint64_t)address, (uint32_t)bytes_read, (uint32_t)byte_size);
568         } else {
569           error.SetErrorStringWithFormat("read memory from 0x%" PRIx64
570                                          " failed (invalid process)",
571                                          (uint64_t)address);
572         }
573       }
574     } else {
575       error.SetErrorStringWithFormat("unsupported AddressType value (%i)",
576                                      address_type);
577     }
578   } else {
579     error.SetErrorStringWithFormat("out of memory");
580   }
581 
582   return error;
583 }
584 
585 Scalar &Value::ResolveValue(ExecutionContext *exe_ctx) {
586   const CompilerType &compiler_type = GetCompilerType();
587   if (compiler_type.IsValid()) {
588     switch (m_value_type) {
589     case eValueTypeScalar: // raw scalar value
590       break;
591 
592     default:
593     case eValueTypeFileAddress:
594     case eValueTypeLoadAddress: // load address value
595     case eValueTypeHostAddress: // host address value (for memory in the process
596                                 // that is using liblldb)
597     {
598       DataExtractor data;
599       lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS);
600       Status error(GetValueAsData(exe_ctx, data, 0, nullptr));
601       if (error.Success()) {
602         Scalar scalar;
603         if (compiler_type.GetValueAsScalar(data, 0, data.GetByteSize(),
604                                            scalar)) {
605           m_value = scalar;
606           m_value_type = eValueTypeScalar;
607         } else {
608           if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) {
609             m_value.Clear();
610             m_value_type = eValueTypeScalar;
611           }
612         }
613       } else {
614         if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) {
615           m_value.Clear();
616           m_value_type = eValueTypeScalar;
617         }
618       }
619     } break;
620     }
621   }
622   return m_value;
623 }
624 
625 Variable *Value::GetVariable() {
626   if (m_context_type == eContextTypeVariable)
627     return static_cast<Variable *>(m_context);
628   return nullptr;
629 }
630 
631 void Value::Clear() {
632   m_value.Clear();
633   m_vector.Clear();
634   m_compiler_type.Clear();
635   m_value_type = eValueTypeScalar;
636   m_context = nullptr;
637   m_context_type = eContextTypeInvalid;
638   m_data_buffer.Clear();
639 }
640 
641 const char *Value::GetValueTypeAsCString(ValueType value_type) {
642   switch (value_type) {
643   case eValueTypeScalar:
644     return "scalar";
645   case eValueTypeVector:
646     return "vector";
647   case eValueTypeFileAddress:
648     return "file address";
649   case eValueTypeLoadAddress:
650     return "load address";
651   case eValueTypeHostAddress:
652     return "host address";
653   };
654   return "???";
655 }
656 
657 const char *Value::GetContextTypeAsCString(ContextType context_type) {
658   switch (context_type) {
659   case eContextTypeInvalid:
660     return "invalid";
661   case eContextTypeRegisterInfo:
662     return "RegisterInfo *";
663   case eContextTypeLLDBType:
664     return "Type *";
665   case eContextTypeVariable:
666     return "Variable *";
667   };
668   return "???";
669 }
670 
671 void Value::ConvertToLoadAddress(Module *module, Target *target) {
672   if (!module || !target || (GetValueType() != eValueTypeFileAddress))
673     return;
674 
675   lldb::addr_t file_addr = GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
676   if (file_addr == LLDB_INVALID_ADDRESS)
677     return;
678 
679   Address so_addr;
680   if (!module->ResolveFileAddress(file_addr, so_addr))
681     return;
682   lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
683   if (load_addr == LLDB_INVALID_ADDRESS)
684     return;
685 
686   SetValueType(Value::eValueTypeLoadAddress);
687   GetScalar() = load_addr;
688 }
689 
690 ValueList::ValueList(const ValueList &rhs) { m_values = rhs.m_values; }
691 
692 const ValueList &ValueList::operator=(const ValueList &rhs) {
693   m_values = rhs.m_values;
694   return *this;
695 }
696 
697 void ValueList::PushValue(const Value &value) { m_values.push_back(value); }
698 
699 size_t ValueList::GetSize() { return m_values.size(); }
700 
701 Value *ValueList::GetValueAtIndex(size_t idx) {
702   if (idx < GetSize()) {
703     return &(m_values[idx]);
704   } else
705     return nullptr;
706 }
707 
708 void ValueList::Clear() { m_values.clear(); }
709