Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Core/ValueObjectMemory.cpp
Line
Count
Source (jump to first uncovered line)
1
//===-- ValueObjectMemory.cpp ---------------------------------------------===//
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/ValueObjectMemory.h"
10
#include "lldb/Core/Value.h"
11
#include "lldb/Core/ValueObject.h"
12
#include "lldb/Symbol/Type.h"
13
#include "lldb/Target/ExecutionContext.h"
14
#include "lldb/Target/Target.h"
15
#include "lldb/Utility/DataExtractor.h"
16
#include "lldb/Utility/Scalar.h"
17
#include "lldb/Utility/Status.h"
18
#include "lldb/lldb-types.h"
19
#include "llvm/Support/ErrorHandling.h"
20
21
#include <cassert>
22
#include <memory>
23
24
namespace lldb_private {
25
class ExecutionContextScope;
26
}
27
28
using namespace lldb;
29
using namespace lldb_private;
30
31
ValueObjectSP ValueObjectMemory::Create(ExecutionContextScope *exe_scope,
32
                                        llvm::StringRef name,
33
                                        const Address &address,
34
0
                                        lldb::TypeSP &type_sp) {
35
0
  auto manager_sp = ValueObjectManager::Create();
36
0
  return (new ValueObjectMemory(exe_scope, *manager_sp, name, address, type_sp))
37
0
      ->GetSP();
38
0
}
39
40
ValueObjectSP ValueObjectMemory::Create(ExecutionContextScope *exe_scope,
41
                                        llvm::StringRef name,
42
                                        const Address &address,
43
207
                                        const CompilerType &ast_type) {
44
207
  auto manager_sp = ValueObjectManager::Create();
45
207
  return (new ValueObjectMemory(exe_scope, *manager_sp, name, address,
46
207
                                ast_type))
47
207
      ->GetSP();
48
207
}
49
50
ValueObjectMemory::ValueObjectMemory(ExecutionContextScope *exe_scope,
51
                                     ValueObjectManager &manager,
52
                                     llvm::StringRef name,
53
                                     const Address &address,
54
                                     lldb::TypeSP &type_sp)
55
    : ValueObject(exe_scope, manager), m_address(address), m_type_sp(type_sp),
56
0
      m_compiler_type() {
57
  // Do not attempt to construct one of these objects with no variable!
58
0
  assert(m_type_sp.get() != nullptr);
59
0
  SetName(ConstString(name));
60
0
  m_value.SetContext(Value::ContextType::LLDBType, m_type_sp.get());
61
0
  TargetSP target_sp(GetTargetSP());
62
0
  lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
63
0
  if (load_address != LLDB_INVALID_ADDRESS) {
64
0
    m_value.SetValueType(Value::ValueType::LoadAddress);
65
0
    m_value.GetScalar() = load_address;
66
0
  } else {
67
0
    lldb::addr_t file_address = m_address.GetFileAddress();
68
0
    if (file_address != LLDB_INVALID_ADDRESS) {
69
0
      m_value.SetValueType(Value::ValueType::FileAddress);
70
0
      m_value.GetScalar() = file_address;
71
0
    } else {
72
0
      m_value.GetScalar() = m_address.GetOffset();
73
0
      m_value.SetValueType(Value::ValueType::Scalar);
74
0
    }
75
0
  }
76
0
}
77
78
ValueObjectMemory::ValueObjectMemory(ExecutionContextScope *exe_scope,
79
                                     ValueObjectManager &manager,
80
                                     llvm::StringRef name,
81
                                     const Address &address,
82
                                     const CompilerType &ast_type)
83
    : ValueObject(exe_scope, manager), m_address(address), m_type_sp(),
84
207
      m_compiler_type(ast_type) {
85
  // Do not attempt to construct one of these objects with no variable!
86
207
  assert(m_compiler_type.GetTypeSystem());
87
0
  assert(m_compiler_type.GetOpaqueQualType());
88
89
0
  TargetSP target_sp(GetTargetSP());
90
91
207
  SetName(ConstString(name));
92
207
  m_value.SetCompilerType(m_compiler_type);
93
207
  lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
94
207
  if (load_address != LLDB_INVALID_ADDRESS) {
95
207
    m_value.SetValueType(Value::ValueType::LoadAddress);
96
207
    m_value.GetScalar() = load_address;
97
207
  } else {
98
0
    lldb::addr_t file_address = m_address.GetFileAddress();
99
0
    if (file_address != LLDB_INVALID_ADDRESS) {
100
0
      m_value.SetValueType(Value::ValueType::FileAddress);
101
0
      m_value.GetScalar() = file_address;
102
0
    } else {
103
0
      m_value.GetScalar() = m_address.GetOffset();
104
0
      m_value.SetValueType(Value::ValueType::Scalar);
105
0
    }
106
0
  }
107
207
}
108
109
207
ValueObjectMemory::~ValueObjectMemory() = default;
110
111
1.28k
CompilerType ValueObjectMemory::GetCompilerTypeImpl() {
112
1.28k
  if (m_type_sp)
113
0
    return m_type_sp->GetForwardCompilerType();
114
1.28k
  return m_compiler_type;
115
1.28k
}
116
117
0
ConstString ValueObjectMemory::GetTypeName() {
118
0
  if (m_type_sp)
119
0
    return m_type_sp->GetName();
120
0
  return m_compiler_type.GetTypeName();
121
0
}
122
123
21
ConstString ValueObjectMemory::GetDisplayTypeName() {
124
21
  if (m_type_sp)
125
0
    return m_type_sp->GetForwardCompilerType().GetDisplayTypeName();
126
21
  return m_compiler_type.GetDisplayTypeName();
127
21
}
128
129
21
size_t ValueObjectMemory::CalculateNumChildren(uint32_t max) {
130
21
  if (m_type_sp) {
131
0
    auto child_count = m_type_sp->GetNumChildren(true);
132
0
    return child_count <= max ? child_count : max;
133
0
  }
134
135
21
  ExecutionContext exe_ctx(GetExecutionContextRef());
136
21
  const bool omit_empty_base_classes = true;
137
21
  auto child_count =
138
21
      m_compiler_type.GetNumChildren(omit_empty_base_classes, &exe_ctx);
139
21
  return child_count <= max ? child_count : 
max0
;
140
21
}
141
142
0
llvm::Optional<uint64_t> ValueObjectMemory::GetByteSize() {
143
0
  ExecutionContext exe_ctx(GetExecutionContextRef());
144
0
  if (m_type_sp)
145
0
    return m_type_sp->GetByteSize(exe_ctx.GetBestExecutionContextScope());
146
0
  return m_compiler_type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
147
0
}
148
149
0
lldb::ValueType ValueObjectMemory::GetValueType() const {
150
  // RETHINK: Should this be inherited from somewhere?
151
0
  return lldb::eValueTypeVariableGlobal;
152
0
}
153
154
207
bool ValueObjectMemory::UpdateValue() {
155
207
  SetValueIsValid(false);
156
207
  m_error.Clear();
157
158
207
  ExecutionContext exe_ctx(GetExecutionContextRef());
159
160
207
  Target *target = exe_ctx.GetTargetPtr();
161
207
  if (target) {
162
207
    m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
163
207
    m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
164
207
  }
165
166
207
  Value old_value(m_value);
167
207
  if (m_address.IsValid()) {
168
207
    Value::ValueType value_type = m_value.GetValueType();
169
170
207
    switch (value_type) {
171
0
    case Value::ValueType::Invalid:
172
0
      m_error.SetErrorString("Invalid value");
173
0
      return false;
174
0
    case Value::ValueType::Scalar:
175
      // The variable value is in the Scalar value inside the m_value. We can
176
      // point our m_data right to it.
177
0
      m_error = m_value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
178
0
      break;
179
180
0
    case Value::ValueType::FileAddress:
181
207
    case Value::ValueType::LoadAddress:
182
207
    case Value::ValueType::HostAddress:
183
      // The DWARF expression result was an address in the inferior process. If
184
      // this variable is an aggregate type, we just need the address as the
185
      // main value as all child variable objects will rely upon this location
186
      // and add an offset and then read their own values as needed. If this
187
      // variable is a simple type, we read all data for it into m_data. Make
188
      // sure this type has a value before we try and read it
189
190
      // If we have a file address, convert it to a load address if we can.
191
207
      if (value_type == Value::ValueType::FileAddress &&
192
207
          
exe_ctx.GetProcessPtr()0
) {
193
0
        lldb::addr_t load_addr = m_address.GetLoadAddress(target);
194
0
        if (load_addr != LLDB_INVALID_ADDRESS) {
195
0
          m_value.SetValueType(Value::ValueType::LoadAddress);
196
0
          m_value.GetScalar() = load_addr;
197
0
        }
198
0
      }
199
200
207
      if (!CanProvideValue()) {
201
        // this value object represents an aggregate type whose children have
202
        // values, but this object does not. So we say we are changed if our
203
        // location has changed.
204
20
        SetValueDidChange(value_type != old_value.GetValueType() ||
205
20
                          m_value.GetScalar() != old_value.GetScalar());
206
187
      } else {
207
        // Copy the Value and set the context to use our Variable so it can
208
        // extract read its value into m_data appropriately
209
187
        Value value(m_value);
210
187
        if (m_type_sp)
211
0
          value.SetContext(Value::ContextType::LLDBType, m_type_sp.get());
212
187
        else {
213
187
          value.SetCompilerType(m_compiler_type);
214
187
        }
215
216
187
        m_error = value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
217
187
      }
218
207
      break;
219
207
    }
220
221
207
    SetValueIsValid(m_error.Success());
222
207
  }
223
207
  return m_error.Success();
224
207
}
225
226
267
bool ValueObjectMemory::IsInScope() {
227
  // FIXME: Maybe try to read the memory address, and if that works, then
228
  // we are in scope?
229
267
  return true;
230
267
}
231
232
430
lldb::ModuleSP ValueObjectMemory::GetModule() { return m_address.GetModule(); }