compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

//===-- sanitizer_stacktrace_libcdep.cc -----------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is shared between AddressSanitizer and ThreadSanitizer
// run-time libraries.
//===----------------------------------------------------------------------===//

#include "sanitizer_common.h"
#include "sanitizer_stacktrace.h"
#include "sanitizer_symbolizer.h"

namespace __sanitizer {

static void PrintStackFramePrefix(InternalScopedString *buffer, uptr frame_num,
                                  uptr pc) {
  buffer->append("    #%zu 0x%zx", frame_num, pc);
}

void StackTrace::PrintStack(const uptr *addr, uptr size) {
  if (addr == 0 || size == 0) {
    Printf("    <empty stack>\n\n");
    return;
  }
  InternalScopedBuffer<char> buff(GetPageSizeCached() * 2);
  InternalScopedBuffer<AddressInfo> addr_frames(64);
  InternalScopedString frame_desc(GetPageSizeCached() * 2);
  uptr frame_num = 0;
  for (uptr i = 0; i < size && addr[i]; i++) {
    // PCs in stack traces are actually the return addresses, that is,
    // addresses of the next instructions after the call.
    uptr pc = GetPreviousInstructionPc(addr[i]);
    uptr addr_frames_num = Symbolizer::GetOrInit()->SymbolizePC(
        pc, addr_frames.data(), addr_frames.size());
    if (addr_frames_num == 0) {
      frame_desc.clear();
      PrintStackFramePrefix(&frame_desc, frame_num, pc);
      frame_desc.append(" (<unknown module>)");
      Printf("%s\n", frame_desc.data());
      frame_num++;
      continue;
    }
    for (uptr j = 0; j < addr_frames_num; j++) {
      AddressInfo &info = addr_frames[j];
      frame_desc.clear();
      PrintStackFramePrefix(&frame_desc, frame_num, pc);
      if (info.function) {
        frame_desc.append(" in %s", info.function);
        // Print offset in function if we don't know the source file.
        if (!info.file && info.function_offset != AddressInfo::kUnknown)
          frame_desc.append("+0x%zx", info.function_offset);
      }
      if (info.file) {
        frame_desc.append(" ");
        PrintSourceLocation(&frame_desc, info.file, info.line, info.column);
      } else if (info.module) {
        frame_desc.append(" ");
        PrintModuleAndOffset(&frame_desc, info.module, info.module_offset);
      }
      Printf("%s\n", frame_desc.data());
      frame_num++;
      info.Clear();
    }
  }
  // Always print a trailing empty line after stack trace.
  Printf("\n");
}

void StackTrace::Unwind(uptr max_depth, uptr pc, uptr bp, void *context,
                        uptr stack_top, uptr stack_bottom,
                        bool request_fast_unwind) {
  top_frame_bp = (max_depth > 0) ? bp : 0;
  // Avoid doing any work for small max_depth.
  if (max_depth == 0) {
    size = 0;
    return;
  }
  if (max_depth == 1) {
    size = 1;
    trace[0] = pc;
    return;
  }
  if (!WillUseFastUnwind(request_fast_unwind)) {
    if (context)
      SlowUnwindStackWithContext(pc, context, max_depth);
    else
      SlowUnwindStack(pc, max_depth);
  } else {
    FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
  }
}

}  // namespace __sanitizer