contrib/compiler-rt/lib/asan/asan_debugging.cc

   1 //===-- asan_debugging.cc -------------------------------------------------===//
   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 // This file is a part of AddressSanitizer, an address sanity checker.
  10 //
  11 // This file contains various functions that are generally useful to call when
  12 // using a debugger (LLDB, GDB).
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "asan_allocator.h"
  16 #include "asan_descriptions.h"
  17 #include "asan_flags.h"
  18 #include "asan_internal.h"
  19 #include "asan_mapping.h"
  20 #include "asan_report.h"
  21 #include "asan_thread.h"
  22
  23 namespace {
  24 using namespace __asan;
  25
  26 static void FindInfoForStackVar(uptr addr, const char *frame_descr, uptr offset,
  27                                 char *name, uptr name_size,
  28                                 uptr &region_address, uptr &region_size) {
  29   InternalMmapVector<StackVarDescr> vars;
  30   vars.reserve(16);
  31   if (!ParseFrameDescription(frame_descr, &vars)) {
  32     return;
  33   }
  34
  35   for (uptr i = 0; i < vars.size(); i++) {
  36     if (offset <= vars[i].beg + vars[i].size) {
  37       // We use name_len + 1 because strlcpy will guarantee a \0 at the end, so
  38       // if we're limiting the copy due to name_len, we add 1 to ensure we copy
  39       // the whole name and then terminate with '\0'.
  40       internal_strlcpy(name, vars[i].name_pos,
  41                        Min(name_size, vars[i].name_len + 1));
  42       region_address = addr - (offset - vars[i].beg);
  43       region_size = vars[i].size;
  44       return;
  45     }
  46   }
  47 }
  48
  49 uptr AsanGetStack(uptr addr, uptr *trace, u32 size, u32 *thread_id,
  50                          bool alloc_stack) {
  51   AsanChunkView chunk = FindHeapChunkByAddress(addr);
  52   if (!chunk.IsValid()) return 0;
  53
  54   StackTrace stack(nullptr, 0);
  55   if (alloc_stack) {
  56     if (chunk.AllocTid() == kInvalidTid) return 0;
  57     stack = chunk.GetAllocStack();
  58     if (thread_id) *thread_id = chunk.AllocTid();
  59   } else {
  60     if (chunk.FreeTid() == kInvalidTid) return 0;
  61     stack = chunk.GetFreeStack();
  62     if (thread_id) *thread_id = chunk.FreeTid();
  63   }
  64
  65   if (trace && size) {
  66     size = Min(size, Min(stack.size, kStackTraceMax));
  67     for (uptr i = 0; i < size; i++)
  68       trace[i] = StackTrace::GetPreviousInstructionPc(stack.trace[i]);
  69
  70     return size;
  71   }
  72
  73   return 0;
  74 }
  75
  76 }  // namespace
  77
  78 SANITIZER_INTERFACE_ATTRIBUTE
  79 const char *__asan_locate_address(uptr addr, char *name, uptr name_size,
  80                                   uptr *region_address_ptr,
  81                                   uptr *region_size_ptr) {
  82   AddressDescription descr(addr);
  83   uptr region_address = 0;
  84   uptr region_size = 0;
  85   const char *region_kind = nullptr;
  86   if (name && name_size > 0) name[0] = 0;
  87
  88   if (auto shadow = descr.AsShadow()) {
  89     // region_{address,size} are already 0
  90     switch (shadow->kind) {
  91       case kShadowKindLow:
  92         region_kind = "low shadow";
  93         break;
  94       case kShadowKindGap:
  95         region_kind = "shadow gap";
  96         break;
  97       case kShadowKindHigh:
  98         region_kind = "high shadow";
  99         break;
 100     }
 101   } else if (auto heap = descr.AsHeap()) {
 102     region_kind = "heap";
 103     region_address = heap->chunk_access.chunk_begin;
 104     region_size = heap->chunk_access.chunk_size;
 105   } else if (auto stack = descr.AsStack()) {
 106     region_kind = "stack";
 107     if (!stack->frame_descr) {
 108       // region_{address,size} are already 0
 109     } else {
 110       FindInfoForStackVar(addr, stack->frame_descr, stack->offset, name,
 111                           name_size, region_address, region_size);
 112     }
 113   } else if (auto global = descr.AsGlobal()) {
 114     region_kind = "global";
 115     auto &g = global->globals[0];
 116     internal_strlcpy(name, g.name, name_size);
 117     region_address = g.beg;
 118     region_size = g.size;
 119   } else {
 120     // region_{address,size} are already 0
 121     region_kind = "heap-invalid";
 122   }
 123
 124   CHECK(region_kind);
 125   if (region_address_ptr) *region_address_ptr = region_address;
 126   if (region_size_ptr) *region_size_ptr = region_size;
 127   return region_kind;
 128 }
 129
 130 SANITIZER_INTERFACE_ATTRIBUTE
 131 uptr __asan_get_alloc_stack(uptr addr, uptr *trace, uptr size, u32 *thread_id) {
 132   return AsanGetStack(addr, trace, size, thread_id, /* alloc_stack */ true);
 133 }
 134
 135 SANITIZER_INTERFACE_ATTRIBUTE
 136 uptr __asan_get_free_stack(uptr addr, uptr *trace, uptr size, u32 *thread_id) {
 137   return AsanGetStack(addr, trace, size, thread_id, /* alloc_stack */ false);
 138 }
 139
 140 SANITIZER_INTERFACE_ATTRIBUTE
 141 void __asan_get_shadow_mapping(uptr *shadow_scale, uptr *shadow_offset) {
 142   if (shadow_scale)
 143     *shadow_scale = SHADOW_SCALE;
 144   if (shadow_offset)
 145     *shadow_offset = SHADOW_OFFSET;
 146 }