Coverage Report

Created: 2022-01-18 06:27

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Core/ValueObjectConstResultImpl.cpp
Line
Count
Source (jump to first uncovered line)
1
//===-- ValueObjectConstResultImpl.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/ValueObjectConstResultImpl.h"
10
11
#include "lldb/Core/Value.h"
12
#include "lldb/Core/ValueObject.h"
13
#include "lldb/Core/ValueObjectConstResult.h"
14
#include "lldb/Core/ValueObjectConstResultCast.h"
15
#include "lldb/Core/ValueObjectConstResultChild.h"
16
#include "lldb/Symbol/CompilerType.h"
17
#include "lldb/Target/ExecutionContext.h"
18
#include "lldb/Utility/DataBufferHeap.h"
19
#include "lldb/Utility/Endian.h"
20
#include "lldb/Utility/Scalar.h"
21
22
#include <string>
23
24
namespace lldb_private {
25
class DataExtractor;
26
}
27
namespace lldb_private {
28
class Status;
29
}
30
31
using namespace lldb;
32
using namespace lldb_private;
33
34
ValueObjectConstResultImpl::ValueObjectConstResultImpl(
35
    ValueObject *valobj, lldb::addr_t live_address)
36
    : m_impl_backend(valobj), m_live_address(live_address),
37
      m_live_address_type(eAddressTypeLoad),
38
53.2k
      m_address_of_backend() {}
39
40
1.15k
lldb::ValueObjectSP ValueObjectConstResultImpl::Dereference(Status &error) {
41
1.15k
  if (m_impl_backend == nullptr)
42
0
    return lldb::ValueObjectSP();
43
44
1.15k
  return m_impl_backend->ValueObject::Dereference(error);
45
1.15k
}
46
47
ValueObject *ValueObjectConstResultImpl::CreateChildAtIndex(
48
12.5k
    size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
49
12.5k
  if (m_impl_backend == nullptr)
50
0
    return nullptr;
51
52
12.5k
  m_impl_backend->UpdateValueIfNeeded(false);
53
54
12.5k
  ValueObjectConstResultChild *valobj = nullptr;
55
56
12.5k
  bool omit_empty_base_classes = true;
57
12.5k
  bool ignore_array_bounds = synthetic_array_member;
58
12.5k
  std::string child_name_str;
59
12.5k
  uint32_t child_byte_size = 0;
60
12.5k
  int32_t child_byte_offset = 0;
61
12.5k
  uint32_t child_bitfield_bit_size = 0;
62
12.5k
  uint32_t child_bitfield_bit_offset = 0;
63
12.5k
  bool child_is_base_class = false;
64
12.5k
  bool child_is_deref_of_parent = false;
65
12.5k
  uint64_t language_flags;
66
67
12.5k
  const bool transparent_pointers = !synthetic_array_member;
68
12.5k
  CompilerType compiler_type = m_impl_backend->GetCompilerType();
69
12.5k
  CompilerType child_compiler_type;
70
71
12.5k
  ExecutionContext exe_ctx(m_impl_backend->GetExecutionContextRef());
72
73
12.5k
  child_compiler_type = compiler_type.GetChildCompilerTypeAtIndex(
74
12.5k
      &exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
75
12.5k
      ignore_array_bounds, child_name_str, child_byte_size, child_byte_offset,
76
12.5k
      child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
77
12.5k
      child_is_deref_of_parent, m_impl_backend, language_flags);
78
79
  // One might think we should check that the size of the children
80
  // is always strictly positive, hence we could avoid creating a
81
  // ValueObject if that's not the case, but it turns out there
82
  // are languages out there which allow zero-size types with
83
  // children (e.g. Swift).
84
12.5k
  if (child_compiler_type) {
85
12.3k
    if (synthetic_index)
86
123
      child_byte_offset += child_byte_size * synthetic_index;
87
88
12.3k
    ConstString child_name;
89
12.3k
    if (!child_name_str.empty())
90
11.5k
      child_name.SetCString(child_name_str.c_str());
91
92
12.3k
    valobj = new ValueObjectConstResultChild(
93
12.3k
        *m_impl_backend, child_compiler_type, child_name, child_byte_size,
94
12.3k
        child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
95
12.3k
        child_is_base_class, child_is_deref_of_parent,
96
12.3k
        m_live_address == LLDB_INVALID_ADDRESS
97
12.3k
            ? 
m_live_address5.68k
98
12.3k
            : 
m_live_address + child_byte_offset6.63k
,
99
12.3k
        language_flags);
100
12.3k
  }
101
102
12.5k
  return valobj;
103
12.5k
}
104
105
lldb::ValueObjectSP ValueObjectConstResultImpl::GetSyntheticChildAtOffset(
106
    uint32_t offset, const CompilerType &type, bool can_create,
107
169
    ConstString name_const_str) {
108
169
  if (m_impl_backend == nullptr)
109
0
    return lldb::ValueObjectSP();
110
111
169
  return m_impl_backend->ValueObject::GetSyntheticChildAtOffset(
112
169
      offset, type, can_create, name_const_str);
113
169
}
114
115
108
lldb::ValueObjectSP ValueObjectConstResultImpl::AddressOf(Status &error) {
116
108
  if (m_address_of_backend.get() != nullptr)
117
36
    return m_address_of_backend;
118
119
72
  if (m_impl_backend == nullptr)
120
0
    return lldb::ValueObjectSP();
121
72
  if (m_live_address != LLDB_INVALID_ADDRESS) {
122
57
    CompilerType compiler_type(m_impl_backend->GetCompilerType());
123
124
57
    lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(
125
57
        &m_live_address, sizeof(lldb::addr_t)));
126
127
57
    std::string new_name("&");
128
57
    new_name.append(m_impl_backend->GetName().AsCString(""));
129
57
    ExecutionContext exe_ctx(m_impl_backend->GetExecutionContextRef());
130
57
    m_address_of_backend = ValueObjectConstResult::Create(
131
57
        exe_ctx.GetBestExecutionContextScope(), compiler_type.GetPointerType(),
132
57
        ConstString(new_name.c_str()), buffer, endian::InlHostByteOrder(),
133
57
        exe_ctx.GetAddressByteSize());
134
135
57
    m_address_of_backend->GetValue().SetValueType(Value::ValueType::Scalar);
136
57
    m_address_of_backend->GetValue().GetScalar() = m_live_address;
137
138
57
    return m_address_of_backend;
139
57
  } else
140
15
    return m_impl_backend->ValueObject::AddressOf(error);
141
72
}
142
143
lldb::ValueObjectSP
144
3
ValueObjectConstResultImpl::Cast(const CompilerType &compiler_type) {
145
3
  if (m_impl_backend == nullptr)
146
0
    return lldb::ValueObjectSP();
147
148
3
  ValueObjectConstResultCast *result_cast =
149
3
      new ValueObjectConstResultCast(*m_impl_backend, m_impl_backend->GetName(),
150
3
                                     compiler_type, m_live_address);
151
3
  return result_cast->GetSP();
152
3
}
153
154
lldb::addr_t
155
ValueObjectConstResultImpl::GetAddressOf(bool scalar_is_load_address,
156
2.93k
                                         AddressType *address_type) {
157
158
2.93k
  if (m_impl_backend == nullptr)
159
0
    return 0;
160
161
2.93k
  if (m_live_address == LLDB_INVALID_ADDRESS) {
162
408
    return m_impl_backend->ValueObject::GetAddressOf(scalar_is_load_address,
163
408
                                                     address_type);
164
408
  }
165
166
2.52k
  if (address_type)
167
2.52k
    *address_type = m_live_address_type;
168
169
2.52k
  return m_live_address;
170
2.93k
}
171
172
size_t ValueObjectConstResultImpl::GetPointeeData(DataExtractor &data,
173
                                                  uint32_t item_idx,
174
2.08k
                                                  uint32_t item_count) {
175
2.08k
  if (m_impl_backend == nullptr)
176
0
    return 0;
177
2.08k
  return m_impl_backend->ValueObject::GetPointeeData(data, item_idx,
178
2.08k
                                                     item_count);
179
2.08k
}