1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
//===-- LocationsRequestHandler.cpp ---------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "DAP.h"
#include "EventHelper.h"
#include "JSONUtils.h"
#include "LLDBUtils.h"
#include "ProtocolUtils.h"
#include "RequestHandler.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBLineEntry.h"
namespace lldb_dap {
// "LocationsRequest": {
// "allOf": [ { "$ref": "#/definitions/Request" }, {
// "type": "object",
// "description": "Looks up information about a location reference
// previously returned by the debug adapter.",
// "properties": {
// "command": {
// "type": "string",
// "enum": [ "locations" ]
// },
// "arguments": {
// "$ref": "#/definitions/LocationsArguments"
// }
// },
// "required": [ "command", "arguments" ]
// }]
// },
// "LocationsArguments": {
// "type": "object",
// "description": "Arguments for `locations` request.",
// "properties": {
// "locationReference": {
// "type": "integer",
// "description": "Location reference to resolve."
// }
// },
// "required": [ "locationReference" ]
// },
// "LocationsResponse": {
// "allOf": [ { "$ref": "#/definitions/Response" }, {
// "type": "object",
// "description": "Response to `locations` request.",
// "properties": {
// "body": {
// "type": "object",
// "properties": {
// "source": {
// "$ref": "#/definitions/Source",
// "description": "The source containing the location; either
// `source.path` or `source.sourceReference` must be
// specified."
// },
// "line": {
// "type": "integer",
// "description": "The line number of the location. The client
// capability `linesStartAt1` determines whether it
// is 0- or 1-based."
// },
// "column": {
// "type": "integer",
// "description": "Position of the location within the `line`. It is
// measured in UTF-16 code units and the client
// capability `columnsStartAt1` determines whether
// it is 0- or 1-based. If no column is given, the
// first position in the start line is assumed."
// },
// "endLine": {
// "type": "integer",
// "description": "End line of the location, present if the location
// refers to a range. The client capability
// `linesStartAt1` determines whether it is 0- or
// 1-based."
// },
// "endColumn": {
// "type": "integer",
// "description": "End position of the location within `endLine`,
// present if the location refers to a range. It is
// measured in UTF-16 code units and the client
// capability `columnsStartAt1` determines whether
// it is 0- or 1-based."
// }
// },
// "required": [ "source", "line" ]
// }
// }
// }]
// },
void LocationsRequestHandler::operator()(
const llvm::json::Object &request) const {
llvm::json::Object response;
FillResponse(request, response);
auto *arguments = request.getObject("arguments");
const auto location_id =
GetInteger<uint64_t>(arguments, "locationReference").value_or(0);
// We use the lowest bit to distinguish between value location and declaration
// location
auto [var_ref, is_value_location] = UnpackLocation(location_id);
lldb::SBValue variable = dap.variables.GetVariable(var_ref);
if (!variable.IsValid()) {
response["success"] = false;
response["message"] = "Invalid variable reference";
dap.SendJSON(llvm::json::Value(std::move(response)));
return;
}
llvm::json::Object body;
if (is_value_location) {
// Get the value location
if (!variable.GetType().IsPointerType() &&
!variable.GetType().IsReferenceType()) {
response["success"] = false;
response["message"] =
"Value locations are only available for pointers and references";
dap.SendJSON(llvm::json::Value(std::move(response)));
return;
}
lldb::addr_t raw_addr = variable.GetValueAsAddress();
lldb::SBAddress addr = dap.target.ResolveLoadAddress(raw_addr);
lldb::SBLineEntry line_entry = GetLineEntryForAddress(dap.target, addr);
if (!line_entry.IsValid()) {
response["success"] = false;
response["message"] = "Failed to resolve line entry for location";
dap.SendJSON(llvm::json::Value(std::move(response)));
return;
}
const std::optional<protocol::Source> source =
CreateSource(line_entry.GetFileSpec());
if (!source) {
response["success"] = false;
response["message"] = "Failed to resolve file path for location";
dap.SendJSON(llvm::json::Value(std::move(response)));
return;
}
body.try_emplace("source", *source);
if (int line = line_entry.GetLine())
body.try_emplace("line", line);
if (int column = line_entry.GetColumn())
body.try_emplace("column", column);
} else {
// Get the declaration location
lldb::SBDeclaration decl = variable.GetDeclaration();
if (!decl.IsValid()) {
response["success"] = false;
response["message"] = "No declaration location available";
dap.SendJSON(llvm::json::Value(std::move(response)));
return;
}
const std::optional<protocol::Source> source =
CreateSource(decl.GetFileSpec());
if (!source) {
response["success"] = false;
response["message"] = "Failed to resolve file path for location";
dap.SendJSON(llvm::json::Value(std::move(response)));
return;
}
body.try_emplace("source", *source);
if (int line = decl.GetLine())
body.try_emplace("line", line);
if (int column = decl.GetColumn())
body.try_emplace("column", column);
}
response.try_emplace("body", std::move(body));
dap.SendJSON(llvm::json::Value(std::move(response)));
}
} // namespace lldb_dap
|
