Coverage Report

Created: 2022-01-25 06:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/InstrumentationRuntime/ASan/InstrumentationRuntimeASan.cpp
Line
Count
Source (jump to first uncovered line)
1
//===-- InstrumentationRuntimeASan.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 "InstrumentationRuntimeASan.h"
10
11
#include "lldb/Breakpoint/StoppointCallbackContext.h"
12
#include "lldb/Core/Debugger.h"
13
#include "lldb/Core/Module.h"
14
#include "lldb/Core/PluginInterface.h"
15
#include "lldb/Core/PluginManager.h"
16
#include "lldb/Core/StreamFile.h"
17
#include "lldb/Core/ValueObject.h"
18
#include "lldb/Expression/UserExpression.h"
19
#include "lldb/Interpreter/CommandReturnObject.h"
20
#include "lldb/Symbol/Symbol.h"
21
#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
22
#include "lldb/Target/StopInfo.h"
23
#include "lldb/Target/Target.h"
24
#include "lldb/Target/Thread.h"
25
#include "lldb/Utility/RegularExpression.h"
26
#include "lldb/Utility/Stream.h"
27
28
#include "llvm/ADT/StringSwitch.h"
29
30
using namespace lldb;
31
using namespace lldb_private;
32
33
LLDB_PLUGIN_DEFINE(InstrumentationRuntimeASan)
34
35
lldb::InstrumentationRuntimeSP
36
2.69k
InstrumentationRuntimeASan::CreateInstance(const lldb::ProcessSP &process_sp) {
37
2.69k
  return InstrumentationRuntimeSP(new InstrumentationRuntimeASan(process_sp));
38
2.69k
}
39
40
3.44k
void InstrumentationRuntimeASan::Initialize() {
41
3.44k
  PluginManager::RegisterPlugin(
42
3.44k
      GetPluginNameStatic(), "AddressSanitizer instrumentation runtime plugin.",
43
3.44k
      CreateInstance, GetTypeStatic);
44
3.44k
}
45
46
3.43k
void InstrumentationRuntimeASan::Terminate() {
47
3.43k
  PluginManager::UnregisterPlugin(CreateInstance);
48
3.43k
}
49
50
11.4k
lldb::InstrumentationRuntimeType InstrumentationRuntimeASan::GetTypeStatic() {
51
11.4k
  return eInstrumentationRuntimeTypeAddressSanitizer;
52
11.4k
}
53
54
2.69k
InstrumentationRuntimeASan::~InstrumentationRuntimeASan() { Deactivate(); }
55
56
const RegularExpression &
57
139k
InstrumentationRuntimeASan::GetPatternForRuntimeLibrary() {
58
  // FIXME: This shouldn't include the "dylib" suffix.
59
139k
  static RegularExpression regex(
60
139k
      llvm::StringRef("libclang_rt.asan_(.*)_dynamic\\.dylib"));
61
139k
  return regex;
62
139k
}
63
64
bool InstrumentationRuntimeASan::CheckIfRuntimeIsValid(
65
2.68k
    const lldb::ModuleSP module_sp) {
66
2.68k
  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
67
2.68k
      ConstString("__asan_get_alloc_stack"), lldb::eSymbolTypeAny);
68
69
2.68k
  return symbol != nullptr;
70
2.68k
}
71
72
const char *address_sanitizer_retrieve_report_data_prefix = R"(
73
extern "C"
74
{
75
int __asan_report_present();
76
void *__asan_get_report_pc();
77
void *__asan_get_report_bp();
78
void *__asan_get_report_sp();
79
void *__asan_get_report_address();
80
const char *__asan_get_report_description();
81
int __asan_get_report_access_type();
82
size_t __asan_get_report_access_size();
83
}
84
)";
85
86
const char *address_sanitizer_retrieve_report_data_command = R"(
87
struct {
88
    int present;
89
    int access_type;
90
    void *pc;
91
    void *bp;
92
    void *sp;
93
    void *address;
94
    size_t access_size;
95
    const char *description;
96
} t;
97
98
t.present = __asan_report_present();
99
t.access_type = __asan_get_report_access_type();
100
t.pc = __asan_get_report_pc();
101
t.bp = __asan_get_report_bp();
102
t.sp = __asan_get_report_sp();
103
t.address = __asan_get_report_address();
104
t.access_size = __asan_get_report_access_size();
105
t.description = __asan_get_report_description();
106
t
107
)";
108
109
0
StructuredData::ObjectSP InstrumentationRuntimeASan::RetrieveReportData() {
110
0
  ProcessSP process_sp = GetProcessSP();
111
0
  if (!process_sp)
112
0
    return StructuredData::ObjectSP();
113
114
0
  ThreadSP thread_sp =
115
0
      process_sp->GetThreadList().GetExpressionExecutionThread();
116
0
  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
117
118
0
  if (!frame_sp)
119
0
    return StructuredData::ObjectSP();
120
121
0
  EvaluateExpressionOptions options;
122
0
  options.SetUnwindOnError(true);
123
0
  options.SetTryAllThreads(true);
124
0
  options.SetStopOthers(true);
125
0
  options.SetIgnoreBreakpoints(true);
126
0
  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
127
0
  options.SetPrefix(address_sanitizer_retrieve_report_data_prefix);
128
0
  options.SetAutoApplyFixIts(false);
129
0
  options.SetLanguage(eLanguageTypeObjC_plus_plus);
130
131
0
  ValueObjectSP return_value_sp;
132
0
  ExecutionContext exe_ctx;
133
0
  Status eval_error;
134
0
  frame_sp->CalculateExecutionContext(exe_ctx);
135
0
  ExpressionResults result = UserExpression::Evaluate(
136
0
      exe_ctx, options, address_sanitizer_retrieve_report_data_command, "",
137
0
      return_value_sp, eval_error);
138
0
  if (result != eExpressionCompleted) {
139
0
    process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
140
0
        "Warning: Cannot evaluate AddressSanitizer expression:\n%s\n",
141
0
        eval_error.AsCString());
142
0
    return StructuredData::ObjectSP();
143
0
  }
144
145
0
  int present = return_value_sp->GetValueForExpressionPath(".present")
146
0
                    ->GetValueAsUnsigned(0);
147
0
  if (present != 1)
148
0
    return StructuredData::ObjectSP();
149
150
0
  addr_t pc =
151
0
      return_value_sp->GetValueForExpressionPath(".pc")->GetValueAsUnsigned(0);
152
  /* commented out because rdar://problem/18533301
153
  addr_t bp =
154
  return_value_sp->GetValueForExpressionPath(".bp")->GetValueAsUnsigned(0);
155
  addr_t sp =
156
  return_value_sp->GetValueForExpressionPath(".sp")->GetValueAsUnsigned(0);
157
  */
158
0
  addr_t address = return_value_sp->GetValueForExpressionPath(".address")
159
0
                       ->GetValueAsUnsigned(0);
160
0
  addr_t access_type =
161
0
      return_value_sp->GetValueForExpressionPath(".access_type")
162
0
          ->GetValueAsUnsigned(0);
163
0
  addr_t access_size =
164
0
      return_value_sp->GetValueForExpressionPath(".access_size")
165
0
          ->GetValueAsUnsigned(0);
166
0
  addr_t description_ptr =
167
0
      return_value_sp->GetValueForExpressionPath(".description")
168
0
          ->GetValueAsUnsigned(0);
169
0
  std::string description;
170
0
  Status error;
171
0
  process_sp->ReadCStringFromMemory(description_ptr, description, error);
172
173
0
  StructuredData::Dictionary *dict = new StructuredData::Dictionary();
174
0
  dict->AddStringItem("instrumentation_class", "AddressSanitizer");
175
0
  dict->AddStringItem("stop_type", "fatal_error");
176
0
  dict->AddIntegerItem("pc", pc);
177
  /* commented out because rdar://problem/18533301
178
  dict->AddIntegerItem("bp", bp);
179
  dict->AddIntegerItem("sp", sp);
180
  */
181
0
  dict->AddIntegerItem("address", address);
182
0
  dict->AddIntegerItem("access_type", access_type);
183
0
  dict->AddIntegerItem("access_size", access_size);
184
0
  dict->AddStringItem("description", description);
185
186
0
  return StructuredData::ObjectSP(dict);
187
0
}
188
189
std::string
190
0
InstrumentationRuntimeASan::FormatDescription(StructuredData::ObjectSP report) {
191
0
  std::string description = std::string(report->GetAsDictionary()
192
0
                                            ->GetValueForKey("description")
193
0
                                            ->GetAsString()
194
0
                                            ->GetValue());
195
0
  return llvm::StringSwitch<std::string>(description)
196
0
      .Case("heap-use-after-free", "Use of deallocated memory")
197
0
      .Case("heap-buffer-overflow", "Heap buffer overflow")
198
0
      .Case("stack-buffer-underflow", "Stack buffer underflow")
199
0
      .Case("initialization-order-fiasco", "Initialization order problem")
200
0
      .Case("stack-buffer-overflow", "Stack buffer overflow")
201
0
      .Case("stack-use-after-return", "Use of stack memory after return")
202
0
      .Case("use-after-poison", "Use of poisoned memory")
203
0
      .Case("container-overflow", "Container overflow")
204
0
      .Case("stack-use-after-scope", "Use of out-of-scope stack memory")
205
0
      .Case("global-buffer-overflow", "Global buffer overflow")
206
0
      .Case("unknown-crash", "Invalid memory access")
207
0
      .Case("stack-overflow", "Stack space exhausted")
208
0
      .Case("null-deref", "Dereference of null pointer")
209
0
      .Case("wild-jump", "Jump to non-executable address")
210
0
      .Case("wild-addr-write", "Write through wild pointer")
211
0
      .Case("wild-addr-read", "Read from wild pointer")
212
0
      .Case("wild-addr", "Access through wild pointer")
213
0
      .Case("signal", "Deadly signal")
214
0
      .Case("double-free", "Deallocation of freed memory")
215
0
      .Case("new-delete-type-mismatch",
216
0
            "Deallocation size different from allocation size")
217
0
      .Case("bad-free", "Deallocation of non-allocated memory")
218
0
      .Case("alloc-dealloc-mismatch",
219
0
            "Mismatch between allocation and deallocation APIs")
220
0
      .Case("bad-malloc_usable_size", "Invalid argument to malloc_usable_size")
221
0
      .Case("bad-__sanitizer_get_allocated_size",
222
0
            "Invalid argument to __sanitizer_get_allocated_size")
223
0
      .Case("param-overlap",
224
0
            "Call to function disallowing overlapping memory ranges")
225
0
      .Case("negative-size-param", "Negative size used when accessing memory")
226
0
      .Case("bad-__sanitizer_annotate_contiguous_container",
227
0
            "Invalid argument to __sanitizer_annotate_contiguous_container")
228
0
      .Case("odr-violation", "Symbol defined in multiple translation units")
229
0
      .Case(
230
0
          "invalid-pointer-pair",
231
0
          "Comparison or arithmetic on pointers from different memory regions")
232
      // for unknown report codes just show the code
233
0
      .Default("AddressSanitizer detected: " + description);
234
0
}
235
236
bool InstrumentationRuntimeASan::NotifyBreakpointHit(
237
    void *baton, StoppointCallbackContext *context, user_id_t break_id,
238
0
    user_id_t break_loc_id) {
239
0
  assert(baton && "null baton");
240
0
  if (!baton)
241
0
    return false;
242
243
0
  InstrumentationRuntimeASan *const instance =
244
0
      static_cast<InstrumentationRuntimeASan *>(baton);
245
246
0
  ProcessSP process_sp = instance->GetProcessSP();
247
248
0
  if (process_sp->GetModIDRef().IsLastResumeForUserExpression())
249
0
    return false;
250
251
0
  StructuredData::ObjectSP report = instance->RetrieveReportData();
252
0
  std::string description;
253
0
  if (report) {
254
0
    description = instance->FormatDescription(report);
255
0
  }
256
  // Make sure this is the right process
257
0
  if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
258
0
    ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
259
0
    if (thread_sp)
260
0
      thread_sp->SetStopInfo(InstrumentationRuntimeStopInfo::
261
0
                                 CreateStopReasonWithInstrumentationData(
262
0
                                     *thread_sp, description, report));
263
264
0
    StreamFileSP stream_sp(
265
0
        process_sp->GetTarget().GetDebugger().GetOutputStreamSP());
266
0
    if (stream_sp) {
267
0
      stream_sp->Printf("AddressSanitizer report breakpoint hit. Use 'thread "
268
0
                        "info -s' to get extended information about the "
269
0
                        "report.\n");
270
0
    }
271
0
    return true; // Return true to stop the target
272
0
  } else
273
0
    return false; // Let target run
274
0
}
275
276
0
void InstrumentationRuntimeASan::Activate() {
277
0
  if (IsActive())
278
0
    return;
279
280
0
  ProcessSP process_sp = GetProcessSP();
281
0
  if (!process_sp)
282
0
    return;
283
284
0
  ConstString symbol_name("__asan::AsanDie()");
285
0
  const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType(
286
0
      symbol_name, eSymbolTypeCode);
287
288
0
  if (symbol == nullptr)
289
0
    return;
290
291
0
  if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
292
0
    return;
293
294
0
  Target &target = process_sp->GetTarget();
295
0
  addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
296
297
0
  if (symbol_address == LLDB_INVALID_ADDRESS)
298
0
    return;
299
300
0
  bool internal = true;
301
0
  bool hardware = false;
302
0
  Breakpoint *breakpoint =
303
0
      process_sp->GetTarget()
304
0
          .CreateBreakpoint(symbol_address, internal, hardware)
305
0
          .get();
306
0
  breakpoint->SetCallback(InstrumentationRuntimeASan::NotifyBreakpointHit, this,
307
0
                          true);
308
0
  breakpoint->SetBreakpointKind("address-sanitizer-report");
309
0
  SetBreakpointID(breakpoint->GetID());
310
311
0
  SetActive(true);
312
0
}
313
314
2.69k
void InstrumentationRuntimeASan::Deactivate() {
315
2.69k
  if (GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
316
0
    ProcessSP process_sp = GetProcessSP();
317
0
    if (process_sp) {
318
0
      process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
319
0
      SetBreakpointID(LLDB_INVALID_BREAK_ID);
320
0
    }
321
0
  }
322
2.69k
  SetActive(false);
323
2.69k
}