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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
//===-- AbortWithPayloadFrameRecognizer.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 "AbortWithPayloadFrameRecognizer.h"
#include "lldb/Core/Value.h"
#include "lldb/Target/ABI.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/ValueObject/ValueObjectConstResult.h"
#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
using namespace lldb;
using namespace lldb_private;
namespace lldb_private {
void RegisterAbortWithPayloadFrameRecognizer(Process *process) {
// There are two user-level API's that this recognizer captures,
// abort_with_reason and abort_with_payload. But they both call the private
// __abort_with_payload, the abort_with_reason call fills in a null payload.
static ConstString module_name("libsystem_kernel.dylib");
static ConstString sym_name("__abort_with_payload");
if (!process)
return;
process->GetTarget().GetFrameRecognizerManager().AddRecognizer(
std::make_shared<AbortWithPayloadFrameRecognizer>(), module_name,
sym_name, Mangled::NamePreference::ePreferDemangled,
/*first_instruction_only*/ false);
}
RecognizedStackFrameSP
AbortWithPayloadFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame_sp) {
// We have two jobs:
// 1) to add the data passed to abort_with_payload to the
// ExtraCrashInformation dictionary.
// 2) To make up faux arguments for this frame.
static constexpr llvm::StringLiteral namespace_key("namespace");
static constexpr llvm::StringLiteral code_key("code");
static constexpr llvm::StringLiteral payload_addr_key("payload_addr");
static constexpr llvm::StringLiteral payload_size_key("payload_size");
static constexpr llvm::StringLiteral reason_key("reason");
static constexpr llvm::StringLiteral flags_key("flags");
static constexpr llvm::StringLiteral info_key("abort_with_payload");
Log *log = GetLog(LLDBLog::SystemRuntime);
if (!frame_sp) {
LLDB_LOG(log, "abort_with_payload recognizer: invalid frame.");
return {};
}
Thread *thread = frame_sp->GetThread().get();
if (!thread) {
LLDB_LOG(log, "abort_with_payload recognizer: invalid thread.");
return {};
}
Process *process = thread->GetProcess().get();
if (!thread) {
LLDB_LOG(log, "abort_with_payload recognizer: invalid process.");
}
TypeSystemClangSP scratch_ts_sp =
ScratchTypeSystemClang::GetForTarget(process->GetTarget());
if (!scratch_ts_sp) {
LLDB_LOG(log, "abort_with_payload recognizer: invalid scratch typesystem.");
return {};
}
// The abort_with_payload signature is:
// abort_with_payload(uint32_t reason_namespace, uint64_t reason_code,
// void* payload, uint32_t payload_size,
// const char* reason_string, uint64_t reason_flags);
ValueList arg_values;
Value input_value_32;
Value input_value_64;
Value input_value_void_ptr;
Value input_value_char_ptr;
CompilerType clang_void_ptr_type =
scratch_ts_sp->GetBasicType(eBasicTypeVoid).GetPointerType();
CompilerType clang_char_ptr_type =
scratch_ts_sp->GetBasicType(eBasicTypeChar).GetPointerType();
CompilerType clang_uint64_type =
scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,
64);
CompilerType clang_uint32_type =
scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,
32);
CompilerType clang_char_star_type =
scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,
64);
input_value_32.SetValueType(Value::ValueType::Scalar);
input_value_32.SetCompilerType(clang_uint32_type);
input_value_64.SetValueType(Value::ValueType::Scalar);
input_value_64.SetCompilerType(clang_uint64_type);
input_value_void_ptr.SetValueType(Value::ValueType::Scalar);
input_value_void_ptr.SetCompilerType(clang_void_ptr_type);
input_value_char_ptr.SetValueType(Value::ValueType::Scalar);
input_value_char_ptr.SetCompilerType(clang_char_ptr_type);
arg_values.PushValue(input_value_32);
arg_values.PushValue(input_value_64);
arg_values.PushValue(input_value_void_ptr);
arg_values.PushValue(input_value_32);
arg_values.PushValue(input_value_char_ptr);
arg_values.PushValue(input_value_64);
lldb::ABISP abi_sp = process->GetABI();
bool success = abi_sp->GetArgumentValues(*thread, arg_values);
if (!success)
return {};
Value *cur_value;
StackFrame *frame = frame_sp.get();
ValueObjectListSP arguments_sp = std::make_shared<ValueObjectList>();
auto add_to_arguments = [&](llvm::StringRef name, Value *value,
bool dynamic) {
ValueObjectSP cur_valobj_sp =
ValueObjectConstResult::Create(frame, *value, ConstString(name));
cur_valobj_sp = ValueObjectRecognizerSynthesizedValue::Create(
*cur_valobj_sp, eValueTypeVariableArgument);
ValueObjectSP dyn_valobj_sp;
if (dynamic) {
dyn_valobj_sp = cur_valobj_sp->GetDynamicValue(eDynamicDontRunTarget);
if (dyn_valobj_sp)
cur_valobj_sp = dyn_valobj_sp;
}
arguments_sp->Append(cur_valobj_sp);
};
// Decode the arg_values:
uint32_t namespace_val = 0;
cur_value = arg_values.GetValueAtIndex(0);
add_to_arguments(namespace_key, cur_value, false);
namespace_val = cur_value->GetScalar().UInt(namespace_val);
uint32_t code_val = 0;
cur_value = arg_values.GetValueAtIndex(1);
add_to_arguments(code_key, cur_value, false);
code_val = cur_value->GetScalar().UInt(code_val);
lldb::addr_t payload_addr = LLDB_INVALID_ADDRESS;
cur_value = arg_values.GetValueAtIndex(2);
add_to_arguments(payload_addr_key, cur_value, true);
payload_addr = cur_value->GetScalar().ULongLong(payload_addr);
uint32_t payload_size = 0;
cur_value = arg_values.GetValueAtIndex(3);
add_to_arguments(payload_size_key, cur_value, false);
payload_size = cur_value->GetScalar().UInt(payload_size);
lldb::addr_t reason_addr = LLDB_INVALID_ADDRESS;
cur_value = arg_values.GetValueAtIndex(4);
add_to_arguments(reason_key, cur_value, false);
reason_addr = cur_value->GetScalar().ULongLong(payload_addr);
// For the reason string, we want the string not the address, so fetch that.
std::string reason_string;
Status error;
process->ReadCStringFromMemory(reason_addr, reason_string, error);
if (error.Fail()) {
// Even if we couldn't read the string, return the other data.
LLDB_LOG(log, "Couldn't fetch reason string: {0}.", error);
reason_string = "<error fetching reason string>";
}
uint32_t flags_val = 0;
cur_value = arg_values.GetValueAtIndex(5);
add_to_arguments(flags_key, cur_value, false);
flags_val = cur_value->GetScalar().UInt(flags_val);
// Okay, we've gotten all the argument values, now put them in a
// StructuredData, and add that to the Process ExtraCrashInformation:
StructuredData::DictionarySP abort_dict_sp(new StructuredData::Dictionary());
abort_dict_sp->AddIntegerItem(namespace_key, namespace_val);
abort_dict_sp->AddIntegerItem(code_key, code_val);
abort_dict_sp->AddIntegerItem(payload_addr_key, payload_addr);
abort_dict_sp->AddIntegerItem(payload_size_key, payload_size);
abort_dict_sp->AddStringItem(reason_key, reason_string);
abort_dict_sp->AddIntegerItem(flags_key, flags_val);
// This will overwrite the abort_with_payload information in the dictionary
// already. But we can only crash on abort_with_payload once, so that
// shouldn't matter.
process->GetExtendedCrashInfoDict()->AddItem(info_key, abort_dict_sp);
return RecognizedStackFrameSP(
new AbortWithPayloadRecognizedStackFrame(frame_sp, arguments_sp));
}
AbortWithPayloadRecognizedStackFrame::AbortWithPayloadRecognizedStackFrame(
lldb::StackFrameSP &frame_sp, ValueObjectListSP &args_sp)
: RecognizedStackFrame() {
m_arguments = args_sp;
m_stop_desc = "abort with payload or reason";
}
} // namespace lldb_private
|
