[sanitizer_common] Add StackTrace::PrintTo method

[gbalats]

Summary

This method is like StackTrace::Print but instead of printing to stderr
it copies its output to a user-provided buffer.

Part of https://reviews.llvm.org/D102451.

[vitalybuka]

In general LGTM, let me take a look closer.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

64

It does not say that it's truncated on \n

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp

21

I don't believe one additional string copy is important here. This code is not expected to
be called frequently. and we have possible symbolizer call and two mmaps in InternalScopedString vectors.

So this can be simplified as this:

//===-- sanitizer_stacktrace_libcdep.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
//
//===----------------------------------------------------------------------===//
//
// This file is shared between AddressSanitizer and ThreadSanitizer
// run-time libraries.
//===----------------------------------------------------------------------===//

#include "sanitizer_common.h"
#include "sanitizer_libc.h"
#include "sanitizer_placement_new.h"
#include "sanitizer_stacktrace.h"
#include "sanitizer_stacktrace_printer.h"
#include "sanitizer_symbolizer.h"

namespace __sanitizer {

namespace {

class StackTraceTextPrinter {
 public:
  StackTraceTextPrinter(const char *stack_trace_fmt, char frame_delimeter,
                        InternalScopedString *output,
                        InternalScopedString *dedup_token)
      : stack_trace_fmt_(stack_trace_fmt),
        frame_delimeter_(frame_delimeter),
        output_(output),
        dedup_token_(dedup_token) {}

  bool ProcessAddressFrames(uptr pc) {
    bool symbolize = RenderNeedsSymbolization(stack_trace_fmt_);
    SymbolizedStack *frames = symbolize
                                  ? Symbolizer::GetOrInit()->SymbolizePC(pc)
                                  : SymbolizedStack::New(pc);
    if (!frames)
      return false;

    for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
      uptr prev_len = output_->length();
      RenderFrame(output_, stack_trace_fmt_, frame_num_++, cur->info.address,
                  symbolize ? &cur->info : nullptr,
                  common_flags()->symbolize_vs_style,
                  common_flags()->strip_path_prefix);

      if (prev_len != output_->length())
        output_->append("%c", frame_delimeter_);

      if (!dedup_token_)
        continue;
      if (dedup_frames_-- > 0) {
        if (dedup_token_->length())
          dedup_token_->append("--");
        if (cur->info.function != nullptr)
          dedup_token_->append(cur->info.function);
      }
    }
    frames->ClearAll();
    return true;
  }

 private:
  const char *stack_trace_fmt_;
  char frame_delimeter_;
  int dedup_frames_ = common_flags()->dedup_token_length;
  uptr frame_num_ = 0;
  InternalScopedString *output_;
  InternalScopedString *dedup_token_;
};

static void CopyString(const InternalScopedString &output, char *out_buf,
                       uptr out_buf_size) {
  if (!out_buf_size)
    return;
  uptr copy_size = Min(output.length(), out_buf_size - 1);
  internal_memcpy(out_buf, output.data(), copy_size);
  out_buf[copy_size] = '\0';
}

}  // namespace

void StackTrace::PrintTo(InternalScopedString *output) const {
  CHECK(output);

  InternalScopedString dedup_token;
  StackTraceTextPrinter printer(common_flags()->stack_trace_format, '\n',
                                output, &dedup_token);

  if (trace == nullptr || size == 0) {
    output->append("    <empty stack>\n\n");
    return;
  }

  for (uptr i = 0; i < size && trace[i]; i++) {
    // PCs in stack traces are actually the return addresses, that is,
    // addresses of the next instructions after the call.
    uptr pc = GetPreviousInstructionPc(trace[i]);
    CHECK(printer.ProcessAddressFrames(pc));
  }

  // Always add a trailing empty line after stack trace.
  output->append("\n");

  // Append deduplication token, if non-empty.
  if (dedup_token.length())
    output->append("DEDUP_TOKEN: %s\n", dedup_token.data());
}

uptr StackTrace::PrintTo(char *out_buf, uptr out_buf_size) const {
  InternalScopedString output;
  PrintTo(&output);
  CopyString(output, out_buf, out_buf_size);
  if (output.length() >= out_buf_size) {
    if (char *last_n = internal_strrchr(out_buf, '\n')) {
      // Trunk after the last '\n' for convenience.
      last_n[1] = '\0';
    } else if (out_buf_size > 1) {
      out_buf[out_buf_size - 2] = '\n';
    }
  }
  return output.length();
}

void StackTrace::Print() const {
  InternalScopedString output;
  PrintTo(&output);
  Printf("%s", output.data());
}

void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
                                uptr stack_top, uptr stack_bottom,
                                bool request_fast_unwind) {
  // Ensures all call sites get what they requested.
  CHECK_EQ(request_fast_unwind, WillUseFastUnwind(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_buffer[0] = pc;
    return;
  }
  if (!WillUseFastUnwind(request_fast_unwind)) {
#if SANITIZER_CAN_SLOW_UNWIND
    if (context)
      UnwindSlow(pc, context, max_depth);
    else
      UnwindSlow(pc, max_depth);
    // If there are too few frames, the program may be built with
    // -fno-asynchronous-unwind-tables. Fall back to fast unwinder below.
    if (size > 2 || size >= max_depth)
      return;
#else
    UNREACHABLE("slow unwind requested but not available");
#endif
  }
  UnwindFast(pc, bp, stack_top, stack_bottom, max_depth);
}

static int GetModuleAndOffsetForPc(uptr pc, char *module_name,
                                   uptr module_name_len, uptr *pc_offset) {
  const char *found_module_name = nullptr;
  bool ok = Symbolizer::GetOrInit()->GetModuleNameAndOffsetForPC(
      pc, &found_module_name, pc_offset);

  if (!ok)
    return false;

  if (module_name && module_name_len) {
    internal_strncpy(module_name, found_module_name, module_name_len);
    module_name[module_name_len - 1] = '\x00';
  }
  return true;
}

}  // namespace __sanitizer
using namespace __sanitizer;

extern "C" {
SANITIZER_INTERFACE_ATTRIBUTE
void __sanitizer_symbolize_pc(uptr pc, const char *fmt, char *out_buf,
                              uptr out_buf_size) {
  if (!out_buf_size)
    return;

  pc = StackTrace::GetPreviousInstructionPc(pc);

  InternalScopedString output;
  StackTraceTextPrinter printer(fmt, '\0', &output, nullptr);
  if (!printer.ProcessAddressFrames(pc)) {
    output.clear();
    output.append("<can't symbolize>");
  }
  CopyString(output, out_buf, out_buf_size);
}

SANITIZER_INTERFACE_ATTRIBUTE
void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
                                  char *out_buf, uptr out_buf_size) {
  if (!out_buf_size)
    return;
  out_buf[0] = 0;
  DataInfo DI;
  if (!Symbolizer::GetOrInit()->SymbolizeData(data_addr, &DI))
    return;
  InternalScopedString data_desc;
  RenderData(&data_desc, fmt, &DI, common_flags()->strip_path_prefix);
  internal_strncpy(out_buf, data_desc.data(), out_buf_size);
  out_buf[out_buf_size - 1] = 0;
}

SANITIZER_INTERFACE_ATTRIBUTE
int __sanitizer_get_module_and_offset_for_pc(uptr pc, char *module_name,
                                             uptr module_name_len,
                                             uptr *pc_offset) {
  return __sanitizer::GetModuleAndOffsetForPc(pc, module_name, module_name_len,
                                              pc_offset);
}
}  // extern "C"

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

170–173

This will modify process state and other tests.
if we execute projects/compiler-rt/lib/sanitizer_common/tests/Sanitizer-x86_64-Test in single process mode all subsequent tests will see this override.
As-is there are no other tests which care about exact format, but it's still not nice.

Please save/restore in flags in:
virtual void SetUp();
virtual void TearDown();

207

StackPrintTo prefix looks redundant

225

there is no test which check if we trunk at existing \n, to avoid incomplete frames.

262

EXPECT_DEATH(trace.PrintTo(buf, 0), "");  // This one should not crash. E.g. EXPECT_GT(trace.PrintTo(buf, 0), 0u);
EXPECT_DEATH(trace.PrintTo(NULL, 100), "");  // This should. Maybe (NULL, 0) is also OK

[gbalats]

Address review comments.

[gbalats]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

64

Removed this behavior and updated tests. See comment below.

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp

21

Thanks! This is much nicer. I didn't know how performance critical this code was so I tried to avoid extra computation.

I made a few changes based on this code:

• some non-functional refactoring changes (e.g., 2nd ctor, const fields, etc)
• re-introduce symbolize_ field to avoid calling RenderNeedsSymbolization multiple times at each ProcessAddressFrames call
• I removed the truncation-at-newline behavior since I don't think we actually need it and one can always do it at the call-site by processing the output buffer (whereas if one wants to maximize trace contents into buffer, it will be impossible).

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

170–173

To clarify, do you think is preferable to

1. rely on default format (which would make the test break when it is changed) and remove these lines?
2. loosen test expectation and only count lines?
3. keep test as is but simply save/restore flags?

I think (1) would make the test a bit more ugly (since there are no function names, which are by default included in the trace) and more prone to breaking.

Also, I wasn't aware that tests can be executed in single process mode. Does this mean that the death test below will make all tests fail, or are they somehow ignored in that mode?

207

Removed.

225

Removed this feature, so no need to add test for it.

262

Placed first expectation on separate non-death test.

[gbalats]

Save/restore flags in SetUp/TearDown.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp

25

This code is internal, called exactly two times. So I would prefer a single constructor with a little bit heavier argument list at two call sites.

30

Not very strongly but I tried to reduce state and remove it from members. But I am OK if we keep it.

36

This one is expected to be called right after constructor.
I prefer to have corresponding constructor parameter instead of this method.

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

170–173

3. LGTM

"single process mode" was wrong set of words.
All these test are part of some GTEST binary. Usually llvm lit runs this binary as multiple parallel processes but each process execute exactly one TEST() using --gtest_filter. In this case none of them will affect each other.

However user can find that binary and directly execute it so all test will be execute in the same process.

And are right about death tests, in any case the are executes with fork() or similar to make sure that parent test does not crash.

225

I didn't mind to have the feature. But either way is fine.

[gbalats]

Change to single constructor.

[gbalats]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp

36

The reason I had it this way is that it would be easy for one to accidentally swap the dedup token and the output parameter since they have the same type.

[gbalats]

Fix string.h include.

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

 //===-- sanitizer_stacktrace.h ----------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_STACKTRACE_H
 #define SANITIZER_STACKTRACE_H
 
+#include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_platform.h"
 
 namespace __sanitizer {
 
 struct BufferedStackTrace;
 
 static const u32 kStackTraceMax = 256;
struct StackTrace {
   StackTrace() : trace(nullptr), size(0), tag(0) {}
   StackTrace(const uptr *trace, u32 size) : trace(trace), size(size), tag(0) {}
   StackTrace(const uptr *trace, u32 size, u32 tag)
       : trace(trace), size(size), tag(tag) {}
 
   // Prints a symbolized stacktrace, followed by an empty line.
   void Print() const;
 
+  // Prints a symbolized stacktrace to the output string, followed by an empty
+  // line.
+  void PrintTo(InternalScopedString *output) const;
+
+  // Prints a symbolized stacktrace to the output buffer, followed by an empty
+  // line. Returns the number of symbols that should have been written to buffer
+  // (not including trailing '\0'). Thus, the string is truncated iff return
+  // value is not less than "out_buf_size".
+  uptr PrintTo(char *out_buf, uptr out_buf_size) const;
+
   static bool WillUseFastUnwind(bool request_fast_unwind) {
     if (!SANITIZER_CAN_FAST_UNWIND)
       return false;
     if (!SANITIZER_CAN_SLOW_UNWIND)
       return true;
     return request_fast_unwind;
   }
 

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp

 #include "sanitizer_common.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_stacktrace_printer.h"
 #include "sanitizer_symbolizer.h"
 
 namespace __sanitizer {
 
-void StackTrace::Print() const {
-  if (trace == nullptr || size == 0) {
-    Printf("    <empty stack>\n\n");
+namespace {
+
+class StackTraceTextPrinter {
+ public:
+  StackTraceTextPrinter(const char *stack_trace_fmt, char frame_delimiter,
+                        InternalScopedString *output)
+      : stack_trace_fmt_(stack_trace_fmt),
+        frame_delimiter_(frame_delimiter),
+        output_(output),
+        symbolize_(RenderNeedsSymbolization(stack_trace_fmt)) {}
+
+  StackTraceTextPrinter(char frame_delimiter, InternalScopedString *output)
+      : StackTraceTextPrinter(common_flags()->stack_trace_format,
+                              frame_delimiter, output) {}
+
+  void SetDedupToken(InternalScopedString *dedup_token) {
+    dedup_token_ = dedup_token;
+    dedup_frames_ = common_flags()->dedup_token_length;
+  }
+
+  bool ProcessAddressFrames(uptr pc) {
+    SymbolizedStack *frames = symbolize_
+                                  ? Symbolizer::GetOrInit()->SymbolizePC(pc)
+                                  : SymbolizedStack::New(pc);
+    if (!frames)
+      return false;
+
+    for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
+      uptr prev_len = output_->length();
+      RenderFrame(output_, stack_trace_fmt_, frame_num_++, cur->info.address,
+                  symbolize_ ? &cur->info : nullptr,
+                  common_flags()->symbolize_vs_style,
+                  common_flags()->strip_path_prefix);
+
+      if (prev_len != output_->length())
+        output_->append("%c", frame_delimiter_);
+
+      ExtendDedupToken(cur);
+    }
+    frames->ClearAll();
+    return true;
+  }
+
+ private:
+  // Extend the dedup token by appending a new frame.
+  void ExtendDedupToken(SymbolizedStack *stack) {
+    if (!dedup_token_)
       return;
-  }
-  InternalScopedString frame_desc;
+
+    if (dedup_frames_-- > 0) {
+      if (dedup_token_->length())
+        dedup_token_->append("--");
+      if (stack->info.function != nullptr)
+        dedup_token_->append(stack->info.function);
+    }
+  }
+
+  const char *stack_trace_fmt_;
+  const char frame_delimiter_;
+  int dedup_frames_ = 0;
+  uptr frame_num_ = 0;
+  InternalScopedString *output_;
+  InternalScopedString *dedup_token_ = nullptr;
+  const bool symbolize_ = false;
+};
+
+static void CopyStringToBuffer(const InternalScopedString &str, char *out_buf,
+                               uptr out_buf_size) {
+  if (!out_buf_size)
+    return;
+
+  CHECK_GT(out_buf_size, 0);
+  uptr copy_size = Min(str.length(), out_buf_size - 1);
+  internal_memcpy(out_buf, str.data(), copy_size);
+  out_buf[copy_size] = '\0';
+
+}  // namespace
+
+void StackTrace::PrintTo(InternalScopedString *output) const {
+  CHECK(output);
+
+  StackTraceTextPrinter printer('\n', output);
+
   InternalScopedString dedup_token;
-  int dedup_frames = common_flags()->dedup_token_length;
-  bool symbolize = RenderNeedsSymbolization(common_flags()->stack_trace_format);
-  uptr frame_num = 0;
+  printer.SetDedupToken(&dedup_token);
+
+  if (trace == nullptr || size == 0) {
+    output->append("    <empty stack>\n\n");
+    return;
+  }
+
   for (uptr i = 0; i < size && trace[i]; i++) {
     // PCs in stack traces are actually the return addresses, that is,
     // addresses of the next instructions after the call.
     uptr pc = GetPreviousInstructionPc(trace[i]);
-    SymbolizedStack *frames;
-    if (symbolize)
-      frames = Symbolizer::GetOrInit()->SymbolizePC(pc);
-    else
-      frames = SymbolizedStack::New(pc);
-    CHECK(frames);
-    for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
-      frame_desc.clear();
-      RenderFrame(&frame_desc, common_flags()->stack_trace_format, frame_num++,
-                  cur->info.address, symbolize ? &cur->info : nullptr,
-                  common_flags()->symbolize_vs_style,
-                  common_flags()->strip_path_prefix);
-      Printf("%s\n", frame_desc.data());
-      if (dedup_frames-- > 0) {
-        if (dedup_token.length())
-          dedup_token.append("--");
-        if (cur->info.function != nullptr)
-          dedup_token.append(cur->info.function);
-      }
-    }
-    frames->ClearAll();
-  }
-  // Always print a trailing empty line after stack trace.
-  Printf("\n");
-  if (dedup_token.length())
-    Printf("DEDUP_TOKEN: %s\n", dedup_token.data());
+    CHECK(printer.ProcessAddressFrames(pc));
+
+  // Always add a trailing empty line after stack trace.
+  output->append("\n");
+
+  // Append deduplication token, if non-empty.
+  if (dedup_token.length())
+    output->append("DEDUP_TOKEN: %s\n", dedup_token.data());
+
+uptr StackTrace::PrintTo(char *out_buf, uptr out_buf_size) const {
+  CHECK(out_buf);
+
+  InternalScopedString output;
+  PrintTo(&output);
+  CopyStringToBuffer(output, out_buf, out_buf_size);
+
+  return output.length();
+
+void StackTrace::Print() const {
+  InternalScopedString output;
+  PrintTo(&output);
+  Printf("%s", output.data());
 }
 
 void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
                                 uptr stack_top, uptr stack_bottom,
                                 bool request_fast_unwind) {
   // Ensures all call sites get what they requested.
   CHECK_EQ(request_fast_unwind, WillUseFastUnwind(request_fast_unwind));
   top_frame_bp = (max_depth > 0) ? bp : 0;

 
 }  // namespace __sanitizer
 using namespace __sanitizer;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_symbolize_pc(uptr pc, const char *fmt, char *out_buf,
                               uptr out_buf_size) {
-  if (!out_buf_size) return;
-  pc = StackTrace::GetPreviousInstructionPc(pc);
-  SymbolizedStack *frame;
-  bool symbolize = RenderNeedsSymbolization(fmt);
-  if (symbolize)
-    frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
-  else
-    frame = SymbolizedStack::New(pc);
-  if (!frame) {
-    internal_strncpy(out_buf, "<can't symbolize>", out_buf_size);
-    out_buf[out_buf_size - 1] = 0;
+  if (!out_buf_size)
     return;
+
+  pc = StackTrace::GetPreviousInstructionPc(pc);
+
+  InternalScopedString output;
+  StackTraceTextPrinter printer(fmt, '\0', &output);
+  if (!printer.ProcessAddressFrames(pc)) {
+    output.clear();
+    output.append("<can't symbolize>");
   }
-  InternalScopedString frame_desc;
-  uptr frame_num = 0;
-  // Reserve one byte for the final 0.
-  char *out_end = out_buf + out_buf_size - 1;
-  for (SymbolizedStack *cur = frame; cur && out_buf < out_end;
-       cur = cur->next) {
-    frame_desc.clear();
-    RenderFrame(&frame_desc, fmt, frame_num++, cur->info.address,
-                symbolize ? &cur->info : nullptr,
-                common_flags()->symbolize_vs_style,
-                common_flags()->strip_path_prefix);
-    if (!frame_desc.length())
-      continue;
-    // Reserve one byte for the terminating 0.
-    uptr n = out_end - out_buf - 1;
-    internal_strncpy(out_buf, frame_desc.data(), n);
-    out_buf += __sanitizer::Min<uptr>(n, frame_desc.length());
-    *out_buf++ = 0;
-  }
-  CHECK(out_buf <= out_end);
-  *out_buf = 0;
-  frame->ClearAll();
+  CopyStringToBuffer(output, out_buf, out_buf_size);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
                                   char *out_buf, uptr out_buf_size) {
   if (!out_buf_size) return;
   out_buf[0] = 0;
   DataInfo DI;

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

 //===-- sanitizer_stacktrace_test.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
 //
 //===----------------------------------------------------------------------===//
 
-#include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
+
 #include "gtest/gtest.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "string.h"
 
 namespace __sanitizer {
 
 class FastUnwindTest : public ::testing::Test {
  protected:
   virtual void SetUp();
   virtual void TearDown();
 
TEST_F(FastUnwindTest, SKIP_ON_SPARC(CloseToZeroFrame)) {
   // The stack should be truncated at the NULL pointer (and not include it).
   EXPECT_EQ(3U, trace.size);
   EXPECT_EQ(start_pc, trace.trace[0]);
   for (uptr i = 1; i < 3U; i++) {
     EXPECT_EQ(PC(i*2 - 1), trace.trace[i]);
   }
 }
 
+using StackPrintTest = FastUnwindTest;
+
+TEST_F(StackPrintTest, SKIP_ON_SPARC(ContainsFullTrace)) {
+  // Override stack trace format to make testing code independent of default
+  // flag values.
+  CommonFlags flags;
+  flags.CopyFrom(*common_flags());
+  flags.stack_trace_format = "#%n %p";
+  OverrideCommonFlags(flags);
+
+  UnwindFast();
+
+  char buf[3000];
+  uptr len = trace.PrintTo(buf, sizeof(buf));
+
+  // This is the no-truncation case.
+  ASSERT_LT(len, sizeof(buf));
+
+  // Printed contents should always end with an empty line, unless truncated.
+  EXPECT_EQ(buf[len - 2], '\n');
+  EXPECT_EQ(buf[len - 1], '\n');
+  EXPECT_EQ(buf[len], '\0');
+
+  // Buffer contents are delimited by newlines, by default.
+  char *saveptr;
+  char *line = strtok_r(buf, "\n", &saveptr);
+
+  // Checks buffer contents line-by-line.
+  for (u32 i = 0; i < trace.size; ++i) {
+    char traceline[100];
+
+    // Should be synced with the stack trace format, set above.
+    snprintf(traceline, sizeof(traceline) - 1, "#%u 0x%lx", i,
+             trace.trace[i] - 1);
+
+    EXPECT_STREQ(line, traceline);
+    line = strtok_r(NULL, "\n", &saveptr);
+  }
+
+  EXPECT_EQ(line, nullptr);
+}
+
+TEST_F(StackPrintTest, SKIP_ON_SPARC(TruncatesContents)) {
+  UnwindFast();
+
+  char buf[3000];
+  uptr actual_len = trace.PrintTo(buf, sizeof(buf));
+  ASSERT_LT(actual_len, sizeof(buf));
+
+  char tinybuf[10];
+  trace.PrintTo(tinybuf, sizeof(tinybuf));
+
+  // This the the truncation case.
+  ASSERT_GT(actual_len, sizeof(tinybuf));
+
+  // The truncated contents should be a prefix of the full contents.
+  size_t lastpos = sizeof(tinybuf) - 1;
+  EXPECT_EQ(strncmp(buf, tinybuf, lastpos), 0);
+  EXPECT_EQ(tinybuf[lastpos], '\0');
+
+  // Full bufffer has more contents...
+  EXPECT_NE(buf[lastpos], '\0');
+}
+
+TEST_F(StackPrintTest, SKIP_ON_SPARC(WorksWithEmptyStack)) {
+  char buf[3000];
+  trace.PrintTo(buf, sizeof(buf));
+  EXPECT_NE(strstr(buf, "<empty stack>"), nullptr);
+}
+
+TEST_F(StackPrintTest, SKIP_ON_SPARC(ReturnsCorrectLength)) {
+  UnwindFast();
+
+  char buf[3000];
+  uptr len = trace.PrintTo(buf, sizeof(buf));
+  size_t actual_len = strlen(buf);
+  ASSERT_LT(len, sizeof(buf));
+  EXPECT_EQ(len, actual_len);
+
+  char tinybuf[5];
+  len = trace.PrintTo(tinybuf, sizeof(tinybuf));
+  size_t truncated_len = strlen(tinybuf);
+  ASSERT_GE(len, sizeof(tinybuf));
+  EXPECT_EQ(len, actual_len);
+  EXPECT_EQ(truncated_len, sizeof(tinybuf) - 1);
+}
+
+TEST_F(StackPrintTest, SKIP_ON_SPARC(AcceptsZeroSize)) {
+  UnwindFast();
+  char buf[1];
+  EXPECT_GT(trace.PrintTo(buf, 0), 0u);
+}
+
+using StackPrintDeathTest = StackPrintTest;
+
+TEST_F(StackPrintDeathTest, SKIP_ON_SPARC(RequiresNonNullBuffer)) {
+  UnwindFast();
+  char buf[100];
+  EXPECT_DEATH(trace.PrintTo(NULL, 100), "");
+}
+
 #endif // SANITIZER_CAN_FAST_UNWIND
 
 TEST(SlowUnwindTest, ShortStackTrace) {
   BufferedStackTrace stack;
   uptr pc = StackTrace::GetCurrentPc();
   uptr bp = GET_CURRENT_FRAME();
   stack.Unwind(pc, bp, nullptr, false, /*max_depth=*/0);
   EXPECT_EQ(0U, stack.size);